Chris@43: ;uInt longest_match_x64(
Chris@43: ;    deflate_state *s,
Chris@43: ;    IPos cur_match);                             /* current match */
Chris@43: 
Chris@43: ; gvmat64.asm -- Asm portion of the optimized longest_match for 32 bits x86_64
Chris@43: ;  (AMD64 on Athlon 64, Opteron, Phenom
Chris@43: ;     and Intel EM64T on Pentium 4 with EM64T, Pentium D, Core 2 Duo, Core I5/I7)
Chris@43: ; Copyright (C) 1995-2010 Jean-loup Gailly, Brian Raiter and Gilles Vollant.
Chris@43: ;
Chris@43: ; File written by Gilles Vollant, by converting to assembly the longest_match
Chris@43: ;  from Jean-loup Gailly in deflate.c of zLib and infoZip zip.
Chris@43: ;
Chris@43: ;  and by taking inspiration on asm686 with masm, optimised assembly code
Chris@43: ;        from Brian Raiter, written 1998
Chris@43: ;
Chris@43: ;  This software is provided 'as-is', without any express or implied
Chris@43: ;  warranty.  In no event will the authors be held liable for any damages
Chris@43: ;  arising from the use of this software.
Chris@43: ;
Chris@43: ;  Permission is granted to anyone to use this software for any purpose,
Chris@43: ;  including commercial applications, and to alter it and redistribute it
Chris@43: ;  freely, subject to the following restrictions:
Chris@43: ;
Chris@43: ;  1. The origin of this software must not be misrepresented; you must not
Chris@43: ;     claim that you wrote the original software. If you use this software
Chris@43: ;     in a product, an acknowledgment in the product documentation would be
Chris@43: ;     appreciated but is not required.
Chris@43: ;  2. Altered source versions must be plainly marked as such, and must not be
Chris@43: ;     misrepresented as being the original software
Chris@43: ;  3. This notice may not be removed or altered from any source distribution.
Chris@43: ;
Chris@43: ;
Chris@43: ;
Chris@43: ;         http://www.zlib.net
Chris@43: ;         http://www.winimage.com/zLibDll
Chris@43: ;         http://www.muppetlabs.com/~breadbox/software/assembly.html
Chris@43: ;
Chris@43: ; to compile this file for infozip Zip, I use option:
Chris@43: ;   ml64.exe /Flgvmat64 /c /Zi /DINFOZIP gvmat64.asm
Chris@43: ;
Chris@43: ; to compile this file for zLib, I use option:
Chris@43: ;   ml64.exe /Flgvmat64 /c /Zi gvmat64.asm
Chris@43: ; Be carrefull to adapt zlib1222add below to your version of zLib
Chris@43: ;   (if you use a version of zLib before 1.0.4 or after 1.2.2.2, change
Chris@43: ;    value of zlib1222add later)
Chris@43: ;
Chris@43: ; This file compile with Microsoft Macro Assembler (x64) for AMD64
Chris@43: ;
Chris@43: ;   ml64.exe is given with Visual Studio 2005/2008/2010 and Windows WDK
Chris@43: ;
Chris@43: ;   (you can get Windows WDK with ml64 for AMD64 from
Chris@43: ;      http://www.microsoft.com/whdc/Devtools/wdk/default.mspx for low price)
Chris@43: ;
Chris@43: 
Chris@43: 
Chris@43: ;uInt longest_match(s, cur_match)
Chris@43: ;    deflate_state *s;
Chris@43: ;    IPos cur_match;                             /* current match */
Chris@43: .code
Chris@43: longest_match PROC
Chris@43: 
Chris@43: 
Chris@43: ;LocalVarsSize   equ 88
Chris@43:  LocalVarsSize   equ 72
Chris@43: 
Chris@43: ; register used : rax,rbx,rcx,rdx,rsi,rdi,r8,r9,r10,r11,r12
Chris@43: ; free register :  r14,r15
Chris@43: ; register can be saved : rsp
Chris@43: 
Chris@43:  chainlenwmask   equ  rsp + 8 - LocalVarsSize    ; high word: current chain len
Chris@43:                                                  ; low word: s->wmask
Chris@43: ;window          equ  rsp + xx - LocalVarsSize   ; local copy of s->window ; stored in r10
Chris@43: ;windowbestlen   equ  rsp + xx - LocalVarsSize   ; s->window + bestlen , use r10+r11
Chris@43: ;scanstart       equ  rsp + xx - LocalVarsSize   ; first two bytes of string ; stored in r12w
Chris@43: ;scanend         equ  rsp + xx - LocalVarsSize   ; last two bytes of string use ebx
Chris@43: ;scanalign       equ  rsp + xx - LocalVarsSize   ; dword-misalignment of string r13
Chris@43: ;bestlen         equ  rsp + xx - LocalVarsSize   ; size of best match so far -> r11d
Chris@43: ;scan            equ  rsp + xx - LocalVarsSize   ; ptr to string wanting match -> r9
Chris@43: IFDEF INFOZIP
Chris@43: ELSE
Chris@43:  nicematch       equ  (rsp + 16 - LocalVarsSize) ; a good enough match size
Chris@43: ENDIF
Chris@43: 
Chris@43: save_rdi        equ  rsp + 24 - LocalVarsSize
Chris@43: save_rsi        equ  rsp + 32 - LocalVarsSize
Chris@43: save_rbx        equ  rsp + 40 - LocalVarsSize
Chris@43: save_rbp        equ  rsp + 48 - LocalVarsSize
Chris@43: save_r12        equ  rsp + 56 - LocalVarsSize
Chris@43: save_r13        equ  rsp + 64 - LocalVarsSize
Chris@43: ;save_r14        equ  rsp + 72 - LocalVarsSize
Chris@43: ;save_r15        equ  rsp + 80 - LocalVarsSize
Chris@43: 
Chris@43: 
Chris@43: ; summary of register usage
Chris@43: ; scanend     ebx
Chris@43: ; scanendw    bx
Chris@43: ; chainlenwmask   edx
Chris@43: ; curmatch    rsi
Chris@43: ; curmatchd   esi
Chris@43: ; windowbestlen   r8
Chris@43: ; scanalign   r9
Chris@43: ; scanalignd  r9d
Chris@43: ; window      r10
Chris@43: ; bestlen     r11
Chris@43: ; bestlend    r11d
Chris@43: ; scanstart   r12d
Chris@43: ; scanstartw  r12w
Chris@43: ; scan        r13
Chris@43: ; nicematch   r14d
Chris@43: ; limit       r15
Chris@43: ; limitd      r15d
Chris@43: ; prev        rcx
Chris@43: 
Chris@43: ;  all the +4 offsets are due to the addition of pending_buf_size (in zlib
Chris@43: ;  in the deflate_state structure since the asm code was first written
Chris@43: ;  (if you compile with zlib 1.0.4 or older, remove the +4).
Chris@43: ;  Note : these value are good with a 8 bytes boundary pack structure
Chris@43: 
Chris@43: 
Chris@43:     MAX_MATCH           equ     258
Chris@43:     MIN_MATCH           equ     3
Chris@43:     MIN_LOOKAHEAD       equ     (MAX_MATCH+MIN_MATCH+1)
Chris@43: 
Chris@43: 
Chris@43: ;;; Offsets for fields in the deflate_state structure. These numbers
Chris@43: ;;; are calculated from the definition of deflate_state, with the
Chris@43: ;;; assumption that the compiler will dword-align the fields. (Thus,
Chris@43: ;;; changing the definition of deflate_state could easily cause this
Chris@43: ;;; program to crash horribly, without so much as a warning at
Chris@43: ;;; compile time. Sigh.)
Chris@43: 
Chris@43: ;  all the +zlib1222add offsets are due to the addition of fields
Chris@43: ;  in zlib in the deflate_state structure since the asm code was first written
Chris@43: ;  (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
Chris@43: ;  (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
Chris@43: ;  if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
Chris@43: 
Chris@43: 
Chris@43: IFDEF INFOZIP
Chris@43: 
Chris@43: _DATA   SEGMENT
Chris@43: COMM    window_size:DWORD
Chris@43: ; WMask ; 7fff
Chris@43: COMM    window:BYTE:010040H
Chris@43: COMM    prev:WORD:08000H
Chris@43: ; MatchLen : unused
Chris@43: ; PrevMatch : unused
Chris@43: COMM    strstart:DWORD
Chris@43: COMM    match_start:DWORD
Chris@43: ; Lookahead : ignore
Chris@43: COMM    prev_length:DWORD ; PrevLen
Chris@43: COMM    max_chain_length:DWORD
Chris@43: COMM    good_match:DWORD
Chris@43: COMM    nice_match:DWORD
Chris@43: prev_ad equ OFFSET prev
Chris@43: window_ad equ OFFSET window
Chris@43: nicematch equ nice_match
Chris@43: _DATA ENDS
Chris@43: WMask equ 07fffh
Chris@43: 
Chris@43: ELSE
Chris@43: 
Chris@43:   IFNDEF zlib1222add
Chris@43:     zlib1222add equ 8
Chris@43:   ENDIF
Chris@43: dsWSize         equ 56+zlib1222add+(zlib1222add/2)
Chris@43: dsWMask         equ 64+zlib1222add+(zlib1222add/2)
Chris@43: dsWindow        equ 72+zlib1222add
Chris@43: dsPrev          equ 88+zlib1222add
Chris@43: dsMatchLen      equ 128+zlib1222add
Chris@43: dsPrevMatch     equ 132+zlib1222add
Chris@43: dsStrStart      equ 140+zlib1222add
Chris@43: dsMatchStart    equ 144+zlib1222add
Chris@43: dsLookahead     equ 148+zlib1222add
Chris@43: dsPrevLen       equ 152+zlib1222add
Chris@43: dsMaxChainLen   equ 156+zlib1222add
Chris@43: dsGoodMatch     equ 172+zlib1222add
Chris@43: dsNiceMatch     equ 176+zlib1222add
Chris@43: 
Chris@43: window_size     equ [ rcx + dsWSize]
Chris@43: WMask           equ [ rcx + dsWMask]
Chris@43: window_ad       equ [ rcx + dsWindow]
Chris@43: prev_ad         equ [ rcx + dsPrev]
Chris@43: strstart        equ [ rcx + dsStrStart]
Chris@43: match_start     equ [ rcx + dsMatchStart]
Chris@43: Lookahead       equ [ rcx + dsLookahead] ; 0ffffffffh on infozip
Chris@43: prev_length     equ [ rcx + dsPrevLen]
Chris@43: max_chain_length equ [ rcx + dsMaxChainLen]
Chris@43: good_match      equ [ rcx + dsGoodMatch]
Chris@43: nice_match      equ [ rcx + dsNiceMatch]
Chris@43: ENDIF
Chris@43: 
Chris@43: ; parameter 1 in r8(deflate state s), param 2 in rdx (cur match)
Chris@43: 
Chris@43: ; see http://weblogs.asp.net/oldnewthing/archive/2004/01/14/58579.aspx and
Chris@43: ; http://msdn.microsoft.com/library/en-us/kmarch/hh/kmarch/64bitAMD_8e951dd2-ee77-4728-8702-55ce4b5dd24a.xml.asp
Chris@43: ;
Chris@43: ; All registers must be preserved across the call, except for
Chris@43: ;   rax, rcx, rdx, r8, r9, r10, and r11, which are scratch.
Chris@43: 
Chris@43: 
Chris@43: 
Chris@43: ;;; Save registers that the compiler may be using, and adjust esp to
Chris@43: ;;; make room for our stack frame.
Chris@43: 
Chris@43: 
Chris@43: ;;; Retrieve the function arguments. r8d will hold cur_match
Chris@43: ;;; throughout the entire function. edx will hold the pointer to the
Chris@43: ;;; deflate_state structure during the function's setup (before
Chris@43: ;;; entering the main loop.
Chris@43: 
Chris@43: ; parameter 1 in rcx (deflate_state* s), param 2 in edx -> r8 (cur match)
Chris@43: 
Chris@43: ; this clear high 32 bits of r8, which can be garbage in both r8 and rdx
Chris@43: 
Chris@43:         mov [save_rdi],rdi
Chris@43:         mov [save_rsi],rsi
Chris@43:         mov [save_rbx],rbx
Chris@43:         mov [save_rbp],rbp
Chris@43: IFDEF INFOZIP
Chris@43:         mov r8d,ecx
Chris@43: ELSE
Chris@43:         mov r8d,edx
Chris@43: ENDIF
Chris@43:         mov [save_r12],r12
Chris@43:         mov [save_r13],r13
Chris@43: ;        mov [save_r14],r14
Chris@43: ;        mov [save_r15],r15
Chris@43: 
Chris@43: 
Chris@43: ;;; uInt wmask = s->w_mask;
Chris@43: ;;; unsigned chain_length = s->max_chain_length;
Chris@43: ;;; if (s->prev_length >= s->good_match) {
Chris@43: ;;;     chain_length >>= 2;
Chris@43: ;;; }
Chris@43: 
Chris@43:         mov edi, prev_length
Chris@43:         mov esi, good_match
Chris@43:         mov eax, WMask
Chris@43:         mov ebx, max_chain_length
Chris@43:         cmp edi, esi
Chris@43:         jl  LastMatchGood
Chris@43:         shr ebx, 2
Chris@43: LastMatchGood:
Chris@43: 
Chris@43: ;;; chainlen is decremented once beforehand so that the function can
Chris@43: ;;; use the sign flag instead of the zero flag for the exit test.
Chris@43: ;;; It is then shifted into the high word, to make room for the wmask
Chris@43: ;;; value, which it will always accompany.
Chris@43: 
Chris@43:         dec ebx
Chris@43:         shl ebx, 16
Chris@43:         or  ebx, eax
Chris@43: 
Chris@43: ;;; on zlib only
Chris@43: ;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
Chris@43: 
Chris@43: IFDEF INFOZIP
Chris@43:         mov [chainlenwmask], ebx
Chris@43: ; on infozip nice_match = [nice_match]
Chris@43: ELSE
Chris@43:         mov eax, nice_match
Chris@43:         mov [chainlenwmask], ebx
Chris@43:         mov r10d, Lookahead
Chris@43:         cmp r10d, eax
Chris@43:         cmovnl r10d, eax
Chris@43:         mov [nicematch],r10d
Chris@43: ENDIF
Chris@43: 
Chris@43: ;;; register Bytef *scan = s->window + s->strstart;
Chris@43:         mov r10, window_ad
Chris@43:         mov ebp, strstart
Chris@43:         lea r13, [r10 + rbp]
Chris@43: 
Chris@43: ;;; Determine how many bytes the scan ptr is off from being
Chris@43: ;;; dword-aligned.
Chris@43: 
Chris@43:          mov r9,r13
Chris@43:          neg r13
Chris@43:          and r13,3
Chris@43: 
Chris@43: ;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
Chris@43: ;;;     s->strstart - (IPos)MAX_DIST(s) : NIL;
Chris@43: IFDEF INFOZIP
Chris@43:         mov eax,07efah ; MAX_DIST = (WSIZE-MIN_LOOKAHEAD) (0x8000-(3+8+1))
Chris@43: ELSE
Chris@43:         mov eax, window_size
Chris@43:         sub eax, MIN_LOOKAHEAD
Chris@43: ENDIF
Chris@43:         xor edi,edi
Chris@43:         sub ebp, eax
Chris@43: 
Chris@43:         mov r11d, prev_length
Chris@43: 
Chris@43:         cmovng ebp,edi
Chris@43: 
Chris@43: ;;; int best_len = s->prev_length;
Chris@43: 
Chris@43: 
Chris@43: ;;; Store the sum of s->window + best_len in esi locally, and in esi.
Chris@43: 
Chris@43:        lea  rsi,[r10+r11]
Chris@43: 
Chris@43: ;;; register ush scan_start = *(ushf*)scan;
Chris@43: ;;; register ush scan_end   = *(ushf*)(scan+best_len-1);
Chris@43: ;;; Posf *prev = s->prev;
Chris@43: 
Chris@43:         movzx r12d,word ptr [r9]
Chris@43:         movzx ebx, word ptr [r9 + r11 - 1]
Chris@43: 
Chris@43:         mov rdi, prev_ad
Chris@43: 
Chris@43: ;;; Jump into the main loop.
Chris@43: 
Chris@43:         mov edx, [chainlenwmask]
Chris@43: 
Chris@43:         cmp bx,word ptr [rsi + r8 - 1]
Chris@43:         jz  LookupLoopIsZero
Chris@43: 
Chris@43: LookupLoop1:
Chris@43:         and r8d, edx
Chris@43: 
Chris@43:         movzx   r8d, word ptr [rdi + r8*2]
Chris@43:         cmp r8d, ebp
Chris@43:         jbe LeaveNow
Chris@43:         sub edx, 00010000h
Chris@43:         js  LeaveNow
Chris@43: 
Chris@43: LoopEntry1:
Chris@43:         cmp bx,word ptr [rsi + r8 - 1]
Chris@43:         jz  LookupLoopIsZero
Chris@43: 
Chris@43: LookupLoop2:
Chris@43:         and r8d, edx
Chris@43: 
Chris@43:         movzx   r8d, word ptr [rdi + r8*2]
Chris@43:         cmp r8d, ebp
Chris@43:         jbe LeaveNow
Chris@43:         sub edx, 00010000h
Chris@43:         js  LeaveNow
Chris@43: 
Chris@43: LoopEntry2:
Chris@43:         cmp bx,word ptr [rsi + r8 - 1]
Chris@43:         jz  LookupLoopIsZero
Chris@43: 
Chris@43: LookupLoop4:
Chris@43:         and r8d, edx
Chris@43: 
Chris@43:         movzx   r8d, word ptr [rdi + r8*2]
Chris@43:         cmp r8d, ebp
Chris@43:         jbe LeaveNow
Chris@43:         sub edx, 00010000h
Chris@43:         js  LeaveNow
Chris@43: 
Chris@43: LoopEntry4:
Chris@43: 
Chris@43:         cmp bx,word ptr [rsi + r8 - 1]
Chris@43:         jnz LookupLoop1
Chris@43:         jmp LookupLoopIsZero
Chris@43: 
Chris@43: 
Chris@43: ;;; do {
Chris@43: ;;;     match = s->window + cur_match;
Chris@43: ;;;     if (*(ushf*)(match+best_len-1) != scan_end ||
Chris@43: ;;;         *(ushf*)match != scan_start) continue;
Chris@43: ;;;     [...]
Chris@43: ;;; } while ((cur_match = prev[cur_match & wmask]) > limit
Chris@43: ;;;          && --chain_length != 0);
Chris@43: ;;;
Chris@43: ;;; Here is the inner loop of the function. The function will spend the
Chris@43: ;;; majority of its time in this loop, and majority of that time will
Chris@43: ;;; be spent in the first ten instructions.
Chris@43: ;;;
Chris@43: ;;; Within this loop:
Chris@43: ;;; ebx = scanend
Chris@43: ;;; r8d = curmatch
Chris@43: ;;; edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
Chris@43: ;;; esi = windowbestlen - i.e., (window + bestlen)
Chris@43: ;;; edi = prev
Chris@43: ;;; ebp = limit
Chris@43: 
Chris@43: LookupLoop:
Chris@43:         and r8d, edx
Chris@43: 
Chris@43:         movzx   r8d, word ptr [rdi + r8*2]
Chris@43:         cmp r8d, ebp
Chris@43:         jbe LeaveNow
Chris@43:         sub edx, 00010000h
Chris@43:         js  LeaveNow
Chris@43: 
Chris@43: LoopEntry:
Chris@43: 
Chris@43:         cmp bx,word ptr [rsi + r8 - 1]
Chris@43:         jnz LookupLoop1
Chris@43: LookupLoopIsZero:
Chris@43:         cmp     r12w, word ptr [r10 + r8]
Chris@43:         jnz LookupLoop1
Chris@43: 
Chris@43: 
Chris@43: ;;; Store the current value of chainlen.
Chris@43:         mov [chainlenwmask], edx
Chris@43: 
Chris@43: ;;; Point edi to the string under scrutiny, and esi to the string we
Chris@43: ;;; are hoping to match it up with. In actuality, esi and edi are
Chris@43: ;;; both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and edx is
Chris@43: ;;; initialized to -(MAX_MATCH_8 - scanalign).
Chris@43: 
Chris@43:         lea rsi,[r8+r10]
Chris@43:         mov rdx, 0fffffffffffffef8h; -(MAX_MATCH_8)
Chris@43:         lea rsi, [rsi + r13 + 0108h] ;MAX_MATCH_8]
Chris@43:         lea rdi, [r9 + r13 + 0108h] ;MAX_MATCH_8]
Chris@43: 
Chris@43:         prefetcht1 [rsi+rdx]
Chris@43:         prefetcht1 [rdi+rdx]
Chris@43: 
Chris@43: 
Chris@43: ;;; Test the strings for equality, 8 bytes at a time. At the end,
Chris@43: ;;; adjust rdx so that it is offset to the exact byte that mismatched.
Chris@43: ;;;
Chris@43: ;;; We already know at this point that the first three bytes of the
Chris@43: ;;; strings match each other, and they can be safely passed over before
Chris@43: ;;; starting the compare loop. So what this code does is skip over 0-3
Chris@43: ;;; bytes, as much as necessary in order to dword-align the edi
Chris@43: ;;; pointer. (rsi will still be misaligned three times out of four.)
Chris@43: ;;;
Chris@43: ;;; It should be confessed that this loop usually does not represent
Chris@43: ;;; much of the total running time. Replacing it with a more
Chris@43: ;;; straightforward "rep cmpsb" would not drastically degrade
Chris@43: ;;; performance.
Chris@43: 
Chris@43: 
Chris@43: LoopCmps:
Chris@43:         mov rax, [rsi + rdx]
Chris@43:         xor rax, [rdi + rdx]
Chris@43:         jnz LeaveLoopCmps
Chris@43: 
Chris@43:         mov rax, [rsi + rdx + 8]
Chris@43:         xor rax, [rdi + rdx + 8]
Chris@43:         jnz LeaveLoopCmps8
Chris@43: 
Chris@43: 
Chris@43:         mov rax, [rsi + rdx + 8+8]
Chris@43:         xor rax, [rdi + rdx + 8+8]
Chris@43:         jnz LeaveLoopCmps16
Chris@43: 
Chris@43:         add rdx,8+8+8
Chris@43: 
Chris@43:         jnz short LoopCmps
Chris@43:         jmp short LenMaximum
Chris@43: LeaveLoopCmps16: add rdx,8
Chris@43: LeaveLoopCmps8: add rdx,8
Chris@43: LeaveLoopCmps:
Chris@43: 
Chris@43:         test    eax, 0000FFFFh
Chris@43:         jnz LenLower
Chris@43: 
Chris@43:         test eax,0ffffffffh
Chris@43: 
Chris@43:         jnz LenLower32
Chris@43: 
Chris@43:         add rdx,4
Chris@43:         shr rax,32
Chris@43:         or ax,ax
Chris@43:         jnz LenLower
Chris@43: 
Chris@43: LenLower32:
Chris@43:         shr eax,16
Chris@43:         add rdx,2
Chris@43: LenLower:   sub al, 1
Chris@43:         adc rdx, 0
Chris@43: ;;; Calculate the length of the match. If it is longer than MAX_MATCH,
Chris@43: ;;; then automatically accept it as the best possible match and leave.
Chris@43: 
Chris@43:         lea rax, [rdi + rdx]
Chris@43:         sub rax, r9
Chris@43:         cmp eax, MAX_MATCH
Chris@43:         jge LenMaximum
Chris@43: 
Chris@43: ;;; If the length of the match is not longer than the best match we
Chris@43: ;;; have so far, then forget it and return to the lookup loop.
Chris@43: ;///////////////////////////////////
Chris@43: 
Chris@43:         cmp eax, r11d
Chris@43:         jg  LongerMatch
Chris@43: 
Chris@43:         lea rsi,[r10+r11]
Chris@43: 
Chris@43:         mov rdi, prev_ad
Chris@43:         mov edx, [chainlenwmask]
Chris@43:         jmp LookupLoop
Chris@43: 
Chris@43: ;;;         s->match_start = cur_match;
Chris@43: ;;;         best_len = len;
Chris@43: ;;;         if (len >= nice_match) break;
Chris@43: ;;;         scan_end = *(ushf*)(scan+best_len-1);
Chris@43: 
Chris@43: LongerMatch:
Chris@43:         mov r11d, eax
Chris@43:         mov match_start, r8d
Chris@43:         cmp eax, [nicematch]
Chris@43:         jge LeaveNow
Chris@43: 
Chris@43:         lea rsi,[r10+rax]
Chris@43: 
Chris@43:         movzx   ebx, word ptr [r9 + rax - 1]
Chris@43:         mov rdi, prev_ad
Chris@43:         mov edx, [chainlenwmask]
Chris@43:         jmp LookupLoop
Chris@43: 
Chris@43: ;;; Accept the current string, with the maximum possible length.
Chris@43: 
Chris@43: LenMaximum:
Chris@43:         mov r11d,MAX_MATCH
Chris@43:         mov match_start, r8d
Chris@43: 
Chris@43: ;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
Chris@43: ;;; return s->lookahead;
Chris@43: 
Chris@43: LeaveNow:
Chris@43: IFDEF INFOZIP
Chris@43:         mov eax,r11d
Chris@43: ELSE
Chris@43:         mov eax, Lookahead
Chris@43:         cmp r11d, eax
Chris@43:         cmovng eax, r11d
Chris@43: ENDIF
Chris@43: 
Chris@43: ;;; Restore the stack and return from whence we came.
Chris@43: 
Chris@43: 
Chris@43:         mov rsi,[save_rsi]
Chris@43:         mov rdi,[save_rdi]
Chris@43:         mov rbx,[save_rbx]
Chris@43:         mov rbp,[save_rbp]
Chris@43:         mov r12,[save_r12]
Chris@43:         mov r13,[save_r13]
Chris@43: ;        mov r14,[save_r14]
Chris@43: ;        mov r15,[save_r15]
Chris@43: 
Chris@43: 
Chris@43:         ret 0
Chris@43: ; please don't remove this string !
Chris@43: ; Your can freely use gvmat64 in any free or commercial app
Chris@43: ; but it is far better don't remove the string in the binary!
Chris@43:     db     0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998, converted to amd 64 by Gilles Vollant 2005",0dh,0ah,0
Chris@43: longest_match   ENDP
Chris@43: 
Chris@43: match_init PROC
Chris@43:   ret 0
Chris@43: match_init ENDP
Chris@43: 
Chris@43: 
Chris@43: END