zlib 1.2.2.3v1.2.2.3

author: Mark Adler <madler@alumni.caltech.edu> 2011-09-09 23:24:43 -0700
committer: Mark Adler <madler@alumni.caltech.edu> 2011-09-09 23:24:43 -0700
commit: 6b8233bfe00e79134cb1b84fc49d4f750a797f79 (patch)
tree: ca2b03b0169568681dc3d9c823e9f0bc4417d6b5 /contrib/masm686
parent: 0484693e1723bbab791c56f95597bd7dbe867d03 (diff)
download: zlib-1.2.2.3.tar.gz
zlib-1.2.2.3.tar.bz2
zlib-1.2.2.3.zip
1 files changed, 413 insertions, 408 deletions
diff --git a/contrib/masm686/match.asm b/contrib/masm686/match.asm
index 2287804..4b03a71 100644
--- a/contrib/masm686/match.asm
+++ b/contrib/masm686/match.asm
@@ -1,408 +1,413 @@
-; match.asm -- Pentium-Pro optimized version of longest_match()
+; match.asm -- Pentium-Pro optimized version of longest_match()
-;
+;
-; Updated for zlib 1.1.3 and converted to MASM 6.1x
+; Updated for zlib 1.1.3 and converted to MASM 6.1x
-; Copyright (C) 2000 Dan Higdon <hdan@kinesoft.com>
+; Copyright (C) 2000 Dan Higdon <hdan@kinesoft.com>
-;                    and Chuck Walbourn <chuckw@kinesoft.com>
+;                    and Chuck Walbourn <chuckw@kinesoft.com>
-; Corrections by Cosmin Truta <cosmint@cs.ubbcluj.ro>
+; Corrections by Cosmin Truta <cosmint@cs.ubbcluj.ro>
-;
+;
-; This is free software; you can redistribute it and/or modify it
+; This is free software; you can redistribute it and/or modify it
-; under the terms of the GNU General Public License.
+; under the terms of the GNU General Public License.
-; Based on match.S
+; Based on match.S
-; Written for zlib 1.1.2
+; Written for zlib 1.1.2
-; Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>
+; Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>
+;
-        .686P
+; Modified by Gilles Vollant (2005) for add gzhead and gzindex
-        .MODEL  FLAT
+        .686P
-;===========================================================================
+        .MODEL  FLAT
-; EQUATES
-;===========================================================================
+;===========================================================================
+; EQUATES
-MAX_MATCH       EQU 258
+;===========================================================================
-MIN_MATCH       EQU 3
-MIN_LOOKAHEAD   EQU (MAX_MATCH + MIN_MATCH + 1)
+MAX_MATCH       EQU 258
-MAX_MATCH_8     EQU ((MAX_MATCH + 7) AND (NOT 7))
+MIN_MATCH       EQU 3
+MIN_LOOKAHEAD   EQU (MAX_MATCH + MIN_MATCH + 1)
-;===========================================================================
+MAX_MATCH_8     EQU ((MAX_MATCH + 7) AND (NOT 7))
-; STRUCTURES
-;===========================================================================
+;===========================================================================
+; STRUCTURES
-; This STRUCT assumes a 4-byte alignment
+;===========================================================================
-DEFLATE_STATE   STRUCT
+; This STRUCT assumes a 4-byte alignment
-ds_strm                 dd ?
-ds_status               dd ?
+DEFLATE_STATE   STRUCT
-ds_pending_buf          dd ?
+ds_strm                 dd ?
-ds_pending_buf_size     dd ?
+ds_status               dd ?
-ds_pending_out          dd ?
+ds_pending_buf          dd ?
-ds_pending              dd ?
+ds_pending_buf_size     dd ?
-ds_wrap                 dd ?
+ds_pending_out          dd ?
-ds_data_type            db ?
+ds_pending              dd ?
-ds_method               db ?
+ds_wrap                 dd ?
-                        db ?    ; padding
+; gzhead and gzindex are added in zlib 1.2.2.2 (see deflate.h)
-                        db ?    ; padding
+ds_gzhead               dd ?
-ds_last_flush           dd ?
+ds_gzindex              dd ?
-ds_w_size               dd ?    ; used
+ds_data_type            db ?
-ds_w_bits               dd ?
+ds_method               db ?
-ds_w_mask               dd ?    ; used
+                        db ?    ; padding
-ds_window               dd ?    ; used
+                        db ?    ; padding
-ds_window_size          dd ?
+ds_last_flush           dd ?
-ds_prev                 dd ?    ; used
+ds_w_size               dd ?    ; used
-ds_head                 dd ?
+ds_w_bits               dd ?
-ds_ins_h                dd ?
+ds_w_mask               dd ?    ; used
-ds_hash_size            dd ?
+ds_window               dd ?    ; used
-ds_hash_bits            dd ?
+ds_window_size          dd ?
-ds_hash_mask            dd ?
+ds_prev                 dd ?    ; used
-ds_hash_shift           dd ?
+ds_head                 dd ?
-ds_block_start          dd ?
+ds_ins_h                dd ?
-ds_match_length         dd ?    ; used
+ds_hash_size            dd ?
-ds_prev_match           dd ?    ; used
+ds_hash_bits            dd ?
-ds_match_available      dd ?
+ds_hash_mask            dd ?
-ds_strstart             dd ?    ; used
+ds_hash_shift           dd ?
-ds_match_start          dd ?    ; used
+ds_block_start          dd ?
-ds_lookahead            dd ?    ; used
+ds_match_length         dd ?    ; used
-ds_prev_length          dd ?    ; used
+ds_prev_match           dd ?    ; used
-ds_max_chain_length     dd ?    ; used
+ds_match_available      dd ?
-ds_max_laxy_match       dd ?
+ds_strstart             dd ?    ; used
-ds_level                dd ?
+ds_match_start          dd ?    ; used
-ds_strategy             dd ?
+ds_lookahead            dd ?    ; used
-ds_good_match           dd ?    ; used
+ds_prev_length          dd ?    ; used
-ds_nice_match           dd ?    ; used
+ds_max_chain_length     dd ?    ; used
+ds_max_laxy_match       dd ?
-; Don't need anymore of the struct for match
+ds_level                dd ?
-DEFLATE_STATE   ENDS
+ds_strategy             dd ?
+ds_good_match           dd ?    ; used
-;===========================================================================
+ds_nice_match           dd ?    ; used
-; CODE
-;===========================================================================
+; Don't need anymore of the struct for match
-_TEXT   SEGMENT
+DEFLATE_STATE   ENDS
-;---------------------------------------------------------------------------
+;===========================================================================
-; match_init
+; CODE
-;---------------------------------------------------------------------------
+;===========================================================================
-        ALIGN   4
+_TEXT   SEGMENT
-PUBLIC  _match_init
-_match_init     PROC
+;---------------------------------------------------------------------------
-        ; no initialization needed
+; match_init
-        ret
+;---------------------------------------------------------------------------
-_match_init     ENDP
+        ALIGN   4
+PUBLIC  _match_init
-;---------------------------------------------------------------------------
+_match_init     PROC
-; uInt longest_match(deflate_state *deflatestate, IPos curmatch)
+        ; no initialization needed
-;---------------------------------------------------------------------------
+        ret
-        ALIGN   4
+_match_init     ENDP
-PUBLIC  _longest_match
+;---------------------------------------------------------------------------
-_longest_match  PROC
+; uInt longest_match(deflate_state *deflatestate, IPos curmatch)
+;---------------------------------------------------------------------------
-; Since this code uses EBP for a scratch register, the stack frame must
+        ALIGN   4
-; be manually constructed and referenced relative to the ESP register.
+PUBLIC  _longest_match
-; Stack image
+_longest_match  PROC
-; Variables
-chainlenwmask   =  0    ; high word: current chain len
+; Since this code uses EBP for a scratch register, the stack frame must
-                        ; low word: s->wmask
+; be manually constructed and referenced relative to the ESP register.
-window          =  4    ; local copy of s->window
-windowbestlen   =  8    ; s->window + bestlen
+; Stack image
-scanend         = 12    ; last two bytes of string
+; Variables
-scanstart       = 16    ; first two bytes of string
+chainlenwmask   =  0    ; high word: current chain len
-scanalign       = 20    ; dword-misalignment of string
+                        ; low word: s->wmask
-nicematch       = 24    ; a good enough match size
+window          =  4    ; local copy of s->window
-bestlen         = 28    ; size of best match so far
+windowbestlen   =  8    ; s->window + bestlen
-scan            = 32    ; ptr to string wanting match
+scanend         = 12    ; last two bytes of string
-varsize         = 36    ; number of bytes (also offset to last saved register)
+scanstart       = 16    ; first two bytes of string
+scanalign       = 20    ; dword-misalignment of string
-; Saved Registers (actually pushed into place)
+nicematch       = 24    ; a good enough match size
-ebx_save        = 36
+bestlen         = 28    ; size of best match so far
-edi_save        = 40
+scan            = 32    ; ptr to string wanting match
-esi_save        = 44
+varsize         = 36    ; number of bytes (also offset to last saved register)
-ebp_save        = 48
+; Saved Registers (actually pushed into place)
-; Parameters
+ebx_save        = 36
-retaddr         = 52
+edi_save        = 40
-deflatestate    = 56
+esi_save        = 44
-curmatch        = 60
+ebp_save        = 48
-; Save registers that the compiler may be using
+; Parameters
-        push    ebp
+retaddr         = 52
-        push    edi
+deflatestate    = 56
-        push    esi
+curmatch        = 60
-        push    ebx
+; Save registers that the compiler may be using
-; Allocate local variable space
+        push    ebp
-        sub     esp,varsize
+        push    edi
+        push    esi
-; Retrieve the function arguments. ecx will hold cur_match
+        push    ebx
-; throughout the entire function. edx will hold the pointer to the
-; deflate_state structure during the function's setup (before
+; Allocate local variable space
-; entering the main loop).
+        sub     esp,varsize
-        mov     edx, [esp+deflatestate]
+; Retrieve the function arguments. ecx will hold cur_match
-ASSUME  edx:PTR DEFLATE_STATE
+; throughout the entire function. edx will hold the pointer to the
+; deflate_state structure during the function's setup (before
-        mov     ecx, [esp+curmatch]
+; entering the main loop).
-; uInt wmask = s->w_mask;
+        mov     edx, [esp+deflatestate]
-; unsigned chain_length = s->max_chain_length;
+ASSUME  edx:PTR DEFLATE_STATE
-; if (s->prev_length >= s->good_match) {
-;     chain_length >>= 2;
+        mov     ecx, [esp+curmatch]
-; }
+; uInt wmask = s->w_mask;
-        mov     eax, [edx].ds_prev_length
+; unsigned chain_length = s->max_chain_length;
-        mov     ebx, [edx].ds_good_match
+; if (s->prev_length >= s->good_match) {
-        cmp     eax, ebx
+;     chain_length >>= 2;
-        mov     eax, [edx].ds_w_mask
+; }
-        mov     ebx, [edx].ds_max_chain_length
-        jl      SHORT LastMatchGood
+        mov     eax, [edx].ds_prev_length
-        shr     ebx, 2
+        mov     ebx, [edx].ds_good_match
-LastMatchGood:
+        cmp     eax, ebx
+        mov     eax, [edx].ds_w_mask
-; chainlen is decremented once beforehand so that the function can
+        mov     ebx, [edx].ds_max_chain_length
-; use the sign flag instead of the zero flag for the exit test.
+        jl      SHORT LastMatchGood
-; It is then shifted into the high word, to make room for the wmask
+        shr     ebx, 2
-; value, which it will always accompany.
+LastMatchGood:
-        dec     ebx
+; chainlen is decremented once beforehand so that the function can
-        shl     ebx, 16
+; use the sign flag instead of the zero flag for the exit test.
-        or      ebx, eax
+; It is then shifted into the high word, to make room for the wmask
-        mov     [esp+chainlenwmask], ebx
+; value, which it will always accompany.
-; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
+        dec     ebx
+        shl     ebx, 16
-        mov     eax, [edx].ds_nice_match
+        or      ebx, eax
-        mov     ebx, [edx].ds_lookahead
+        mov     [esp+chainlenwmask], ebx
-        cmp     ebx, eax
-        jl      SHORT LookaheadLess
+; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
-        mov     ebx, eax
-LookaheadLess:
+        mov     eax, [edx].ds_nice_match
-        mov     [esp+nicematch], ebx
+        mov     ebx, [edx].ds_lookahead
+        cmp     ebx, eax
-;/* register Bytef *scan = s->window + s->strstart;                     */
+        jl      SHORT LookaheadLess
+        mov     ebx, eax
-        mov     esi, [edx].ds_window
+LookaheadLess:
-        mov     [esp+window], esi
+        mov     [esp+nicematch], ebx
-        mov     ebp, [edx].ds_strstart
-        lea     edi, [esi+ebp]
+;/* register Bytef *scan = s->window + s->strstart;                     */
-        mov     [esp+scan],edi
+        mov     esi, [edx].ds_window
-;/* Determine how many bytes the scan ptr is off from being             */
+        mov     [esp+window], esi
-;/* dword-aligned.                                                      */
+        mov     ebp, [edx].ds_strstart
+        lea     edi, [esi+ebp]
-        mov     eax, edi
+        mov     [esp+scan],edi
-        neg     eax
-        and     eax, 3
+;/* Determine how many bytes the scan ptr is off from being             */
-        mov     [esp+scanalign], eax
+;/* dword-aligned.                                                      */
-;/* IPos limit = s->strstart > (IPos)MAX_DIST(s) ?                      */
+        mov     eax, edi
-;/*     s->strstart - (IPos)MAX_DIST(s) : NIL;                          */
+        neg     eax
+        and     eax, 3
-        mov     eax, [edx].ds_w_size
+        mov     [esp+scanalign], eax
-        sub     eax, MIN_LOOKAHEAD
-        sub     ebp, eax
+;/* IPos limit = s->strstart > (IPos)MAX_DIST(s) ?                      */
-        jg      SHORT LimitPositive
+;/*     s->strstart - (IPos)MAX_DIST(s) : NIL;                          */
-        xor     ebp, ebp
-LimitPositive:
+        mov     eax, [edx].ds_w_size
+        sub     eax, MIN_LOOKAHEAD
-;/* int best_len = s->prev_length;                                      */
+        sub     ebp, eax
+        jg      SHORT LimitPositive
-        mov     eax, [edx].ds_prev_length
+        xor     ebp, ebp
-        mov     [esp+bestlen], eax
+LimitPositive:
-;/* Store the sum of s->window + best_len in %esi locally, and in %esi. */
+;/* int best_len = s->prev_length;                                      */
-        add     esi, eax
+        mov     eax, [edx].ds_prev_length
-        mov     [esp+windowbestlen], esi
+        mov     [esp+bestlen], eax
-;/* register ush scan_start = *(ushf*)scan;                             */
+;/* Store the sum of s->window + best_len in %esi locally, and in %esi. */
-;/* register ush scan_end   = *(ushf*)(scan+best_len-1);                */
-;/* Posf *prev = s->prev;                                               */
+        add     esi, eax
+        mov     [esp+windowbestlen], esi
-        movzx   ebx, WORD PTR[edi]
-        mov     [esp+scanstart], ebx
+;/* register ush scan_start = *(ushf*)scan;                             */
-        movzx   ebx, WORD PTR[eax+edi-1]
+;/* register ush scan_end   = *(ushf*)(scan+best_len-1);                */
-        mov     [esp+scanend], ebx
+;/* Posf *prev = s->prev;                                               */
-        mov     edi, [edx].ds_prev
+        movzx   ebx, WORD PTR[edi]
-;/* Jump into the main loop.                                            */
+        mov     [esp+scanstart], ebx
+        movzx   ebx, WORD PTR[eax+edi-1]
-        mov     edx, [esp+chainlenwmask]
+        mov     [esp+scanend], ebx
-        jmp     SHORT LoopEntry
+        mov     edi, [edx].ds_prev
-;/* do {
+;/* Jump into the main loop.                                            */
-; *     match = s->window + cur_match;
-; *     if (*(ushf*)(match+best_len-1) != scan_end ||
+        mov     edx, [esp+chainlenwmask]
-; *         *(ushf*)match != scan_start) continue;
+        jmp     SHORT LoopEntry
-; *     [...]
-; * } while ((cur_match = prev[cur_match & wmask]) > limit
+;/* do {
-; *          && --chain_length != 0);
+; *     match = s->window + cur_match;
-; *
+; *     if (*(ushf*)(match+best_len-1) != scan_end ||
-; * Here is the inner loop of the function. The function will spend the
+; *         *(ushf*)match != scan_start) continue;
-; * majority of its time in this loop, and majority of that time will
+; *     [...]
-; * be spent in the first ten instructions.
+; * } while ((cur_match = prev[cur_match & wmask]) > limit
-; *
+; *          && --chain_length != 0);
-; * Within this loop:
+; *
-; * %ebx = scanend
+; * Here is the inner loop of the function. The function will spend the
-; * %ecx = curmatch
+; * majority of its time in this loop, and majority of that time will
-; * %edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
+; * be spent in the first ten instructions.
-; * %esi = windowbestlen - i.e., (window + bestlen)
+; *
-; * %edi = prev
+; * Within this loop:
-; * %ebp = limit
+; * %ebx = scanend
-; */
+; * %ecx = curmatch
+; * %edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
-        ALIGN   4
+; * %esi = windowbestlen - i.e., (window + bestlen)
-LookupLoop:
+; * %edi = prev
-        and     ecx, edx
+; * %ebp = limit
-        movzx   ecx, WORD PTR[edi+ecx*2]
+; */
-        cmp     ecx, ebp
-        jbe     LeaveNow
+        ALIGN   4
-        sub     edx, 000010000H
+LookupLoop:
-        js      LeaveNow
+        and     ecx, edx
+        movzx   ecx, WORD PTR[edi+ecx*2]
-LoopEntry:
+        cmp     ecx, ebp
-        movzx   eax, WORD PTR[esi+ecx-1]
+        jbe     LeaveNow
-        cmp     eax, ebx
+        sub     edx, 000010000H
-        jnz     SHORT LookupLoop
+        js      LeaveNow
-        mov     eax, [esp+window]
+LoopEntry:
-        movzx   eax, WORD PTR[eax+ecx]
+        movzx   eax, WORD PTR[esi+ecx-1]
-        cmp     eax, [esp+scanstart]
+        cmp     eax, ebx
-        jnz     SHORT LookupLoop
+        jnz     SHORT LookupLoop
-;/* Store the current value of chainlen.                                */
+        mov     eax, [esp+window]
+        movzx   eax, WORD PTR[eax+ecx]
-        mov     [esp+chainlenwmask], edx
+        cmp     eax, [esp+scanstart]
+        jnz     SHORT LookupLoop
-;/* 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     */
+;/* Store the current value of chainlen.                                */
-;/* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is     */
-;/* initialized to -(MAX_MATCH_8 - scanalign).                          */
+        mov     [esp+chainlenwmask], edx
-        mov     esi, [esp+window]
+;/* Point %edi to the string under scrutiny, and %esi to the string we  */
-        mov     edi, [esp+scan]
+;/* are hoping to match it up with. In actuality, %esi and %edi are     */
-        add     esi, ecx
+;/* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is     */
-        mov     eax, [esp+scanalign]
+;/* initialized to -(MAX_MATCH_8 - scanalign).                          */
-        mov     edx, -MAX_MATCH_8
-        lea     edi, [edi+eax+MAX_MATCH_8]
+        mov     esi, [esp+window]
-        lea     esi, [esi+eax+MAX_MATCH_8]
+        mov     edi, [esp+scan]
+        add     esi, ecx
-;/* Test the strings for equality, 8 bytes at a time. At the end,
+        mov     eax, [esp+scanalign]
-; * adjust %edx so that it is offset to the exact byte that mismatched.
+        mov     edx, -MAX_MATCH_8
-; *
+        lea     edi, [edi+eax+MAX_MATCH_8]
-; * We already know at this point that the first three bytes of the
+        lea     esi, [esi+eax+MAX_MATCH_8]
-; * 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
+;/* Test the strings for equality, 8 bytes at a time. At the end,
-; * bytes, as much as necessary in order to dword-align the %edi
+; * adjust %edx so that it is offset to the exact byte that mismatched.
-; * pointer. (%esi will still be misaligned three times out of four.)
+; *
-; *
+; * We already know at this point that the first three bytes of the
-; * It should be confessed that this loop usually does not represent
+; * strings match each other, and they can be safely passed over before
-; * much of the total running time. Replacing it with a more
+; * starting the compare loop. So what this code does is skip over 0-3
-; * straightforward "rep cmpsb" would not drastically degrade
+; * bytes, as much as necessary in order to dword-align the %edi
-; * performance.
+; * pointer. (%esi will still be misaligned three times out of four.)
-; */
+; *
+; * It should be confessed that this loop usually does not represent
-LoopCmps:
+; * much of the total running time. Replacing it with a more
-        mov     eax, DWORD PTR[esi+edx]
+; * straightforward "rep cmpsb" would not drastically degrade
-        xor     eax, DWORD PTR[edi+edx]
+; * performance.
-        jnz     SHORT LeaveLoopCmps
+; */
-        mov     eax, DWORD PTR[esi+edx+4]
+LoopCmps:
-        xor     eax, DWORD PTR[edi+edx+4]
+        mov     eax, DWORD PTR[esi+edx]
-        jnz     SHORT LeaveLoopCmps4
+        xor     eax, DWORD PTR[edi+edx]
+        jnz     SHORT LeaveLoopCmps
-        add     edx, 8
-        jnz     SHORT LoopCmps
+        mov     eax, DWORD PTR[esi+edx+4]
-        jmp     LenMaximum
+        xor     eax, DWORD PTR[edi+edx+4]
-        ALIGN   4
+        jnz     SHORT LeaveLoopCmps4
-LeaveLoopCmps4:
+        add     edx, 8
-        add     edx, 4
+        jnz     SHORT LoopCmps
+        jmp     LenMaximum
-LeaveLoopCmps:
+        ALIGN   4
-        test    eax, 00000FFFFH
-        jnz     SHORT LenLower
+LeaveLoopCmps4:
+        add     edx, 4
-        add     edx, 2
-        shr     eax, 16
+LeaveLoopCmps:
+        test    eax, 00000FFFFH
-LenLower:
+        jnz     SHORT LenLower
-        sub     al, 1
-        adc     edx, 0
+        add     edx, 2
+        shr     eax, 16
-;/* Calculate the length of the match. If it is longer than MAX_MATCH,  */
-;/* then automatically accept it as the best possible match and leave.  */
+LenLower:
+        sub     al, 1
-        lea     eax, [edi+edx]
+        adc     edx, 0
-        mov     edi, [esp+scan]
-        sub     eax, edi
+;/* Calculate the length of the match. If it is longer than MAX_MATCH,  */
-        cmp     eax, MAX_MATCH
+;/* then automatically accept it as the best possible match and leave.  */
-        jge     SHORT LenMaximum
+        lea     eax, [edi+edx]
-;/* If the length of the match is not longer than the best match we     */
+        mov     edi, [esp+scan]
-;/* have so far, then forget it and return to the lookup loop.          */
+        sub     eax, edi
+        cmp     eax, MAX_MATCH
-        mov     edx, [esp+deflatestate]
+        jge     SHORT LenMaximum
-        mov     ebx, [esp+bestlen]
-        cmp     eax, ebx
+;/* If the length of the match is not longer than the best match we     */
-        jg      SHORT LongerMatch
+;/* have so far, then forget it and return to the lookup loop.          */
-        mov     esi, [esp+windowbestlen]
-        mov     edi, [edx].ds_prev
+        mov     edx, [esp+deflatestate]
-        mov     ebx, [esp+scanend]
+        mov     ebx, [esp+bestlen]
-        mov     edx, [esp+chainlenwmask]
+        cmp     eax, ebx
-        jmp     LookupLoop
+        jg      SHORT LongerMatch
-        ALIGN   4
+        mov     esi, [esp+windowbestlen]
+        mov     edi, [edx].ds_prev
-;/*         s->match_start = cur_match;                                 */
+        mov     ebx, [esp+scanend]
-;/*         best_len = len;                                             */
+        mov     edx, [esp+chainlenwmask]
-;/*         if (len >= nice_match) break;                               */
+        jmp     LookupLoop
-;/*         scan_end = *(ushf*)(scan+best_len-1);                       */
+        ALIGN   4
-LongerMatch:
+;/*         s->match_start = cur_match;                                 */
-        mov     ebx, [esp+nicematch]
+;/*         best_len = len;                                             */
-        mov     [esp+bestlen], eax
+;/*         if (len >= nice_match) break;                               */
-        mov     [edx].ds_match_start, ecx
+;/*         scan_end = *(ushf*)(scan+best_len-1);                       */
-        cmp     eax, ebx
-        jge     SHORT LeaveNow
+LongerMatch:
-        mov     esi, [esp+window]
+        mov     ebx, [esp+nicematch]
-        add     esi, eax
+        mov     [esp+bestlen], eax
-        mov     [esp+windowbestlen], esi
+        mov     [edx].ds_match_start, ecx
-        movzx   ebx, WORD PTR[edi+eax-1]
+        cmp     eax, ebx
-        mov     edi, [edx].ds_prev
+        jge     SHORT LeaveNow
-        mov     [esp+scanend], ebx
+        mov     esi, [esp+window]
-        mov     edx, [esp+chainlenwmask]
+        add     esi, eax
-        jmp     LookupLoop
+        mov     [esp+windowbestlen], esi
-        ALIGN   4
+        movzx   ebx, WORD PTR[edi+eax-1]
+        mov     edi, [edx].ds_prev
-;/* Accept the current string, with the maximum possible length.        */
+        mov     [esp+scanend], ebx
+        mov     edx, [esp+chainlenwmask]
-LenMaximum:
+        jmp     LookupLoop
-        mov     edx, [esp+deflatestate]
+        ALIGN   4
-        mov     DWORD PTR[esp+bestlen], MAX_MATCH
-        mov     [edx].ds_match_start, ecx
+;/* Accept the current string, with the maximum possible length.        */
-;/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len;          */
+LenMaximum:
-;/* return s->lookahead;                                                */
+        mov     edx, [esp+deflatestate]
+        mov     DWORD PTR[esp+bestlen], MAX_MATCH
-LeaveNow:
+        mov     [edx].ds_match_start, ecx
-        mov     edx, [esp+deflatestate]
-        mov     ebx, [esp+bestlen]
+;/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len;          */
-        mov     eax, [edx].ds_lookahead
+;/* return s->lookahead;                                                */
-        cmp     ebx, eax
-        jg      SHORT LookaheadRet
+LeaveNow:
-        mov     eax, ebx
+        mov     edx, [esp+deflatestate]
-LookaheadRet:
+        mov     ebx, [esp+bestlen]
+        mov     eax, [edx].ds_lookahead
-; Restore the stack and return from whence we came.
+        cmp     ebx, eax
+        jg      SHORT LookaheadRet
-        add     esp, varsize
+        mov     eax, ebx
-        pop     ebx
+LookaheadRet:
-        pop     esi
-        pop     edi
+; Restore the stack and return from whence we came.
-        pop     ebp
-        ret
+        add     esp, varsize
+        pop     ebx
-_longest_match  ENDP
+        pop     esi
+        pop     edi
-_TEXT   ENDS
+        pop     ebp
-END
+        ret
+_longest_match  ENDP
+_TEXT   ENDS
+END
author	Mark Adler <madler@alumni.caltech.edu>	2011-09-09 23:24:43 -0700
committer	Mark Adler <madler@alumni.caltech.edu>	2011-09-09 23:24:43 -0700
commit	6b8233bfe00e79134cb1b84fc49d4f750a797f79 (patch)
tree	ca2b03b0169568681dc3d9c823e9f0bc4417d6b5 /contrib/masm686
parent	0484693e1723bbab791c56f95597bd7dbe867d03 (diff)
download	zlib-1.2.2.3.tar.gz zlib-1.2.2.3.tar.bz2 zlib-1.2.2.3.zip