contrib/gcc_gvmat64/gvmat64.S

/*
;uInt longest_match_x64(
;    deflate_state *s,
;    IPos cur_match);                             // current match 

; gvmat64.S -- Asm portion of the optimized longest_match for 32 bits x86_64
;  (AMD64 on Athlon 64, Opteron, Phenom
;     and Intel EM64T on Pentium 4 with EM64T, Pentium D, Core 2 Duo, Core I5/I7)
; this file is translation from gvmat64.asm to GCC 4.x (for Linux, Mac XCode)
; Copyright (C) 1995-2010 Jean-loup Gailly, Brian Raiter and Gilles Vollant.
;
; File written by Gilles Vollant, by converting to assembly the longest_match
;  from Jean-loup Gailly in deflate.c of zLib and infoZip zip.
;  and by taking inspiration on asm686 with masm, optimised assembly code
;        from Brian Raiter, written 1998
;
;  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.
;
;         http://www.zlib.net
;         http://www.winimage.com/zLibDll
;         http://www.muppetlabs.com/~breadbox/software/assembly.html
;
; to compile this file for zLib, I use option:
;   gcc -c -arch x86_64 gvmat64.S


;uInt longest_match(s, cur_match)
;    deflate_state *s;
;    IPos cur_match;                             // current match /
;
; with XCode for Mac, I had strange error with some jump on intel syntax
; this is why BEFORE_JMP and AFTER_JMP are used
 */


#define BEFORE_JMP .att_syntax
#define AFTER_JMP .intel_syntax noprefix

#ifndef NO_UNDERLINE
#       define  match_init      _match_init
#       define  longest_match   _longest_match
#endif

.intel_syntax noprefix

.globl  match_init, longest_match
.text
longest_match:


#define LocalVarsSize 96
/*
; register used : rax,rbx,rcx,rdx,rsi,rdi,r8,r9,r10,r11,r12
; free register :  r14,r15
; register can be saved : rsp
*/

#define chainlenwmask     (rsp + 8 - LocalVarsSize)
#define nicematch         (rsp + 16 - LocalVarsSize)

#define save_rdi        (rsp + 24 - LocalVarsSize)
#define save_rsi        (rsp + 32 - LocalVarsSize)
#define save_rbx        (rsp + 40 - LocalVarsSize)
#define save_rbp        (rsp + 48 - LocalVarsSize)
#define save_r12        (rsp + 56 - LocalVarsSize)
#define save_r13        (rsp + 64 - LocalVarsSize)
#define save_r14        (rsp + 72 - LocalVarsSize)
#define save_r15        (rsp + 80 - LocalVarsSize)


/*
;  all the +4 offsets are due to the addition of pending_buf_size (in zlib
;  in the deflate_state structure since the asm code was first written
;  (if you compile with zlib 1.0.4 or older, remove the +4).
;  Note : these value are good with a 8 bytes boundary pack structure
*/

#define    MAX_MATCH              258
#define    MIN_MATCH              3
#define    MIN_LOOKAHEAD          (MAX_MATCH+MIN_MATCH+1)

/*
;;; 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.)

;  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").
*/


/* you can check the structure offset by running

#include <stdlib.h>
#include <stdio.h>
#include "deflate.h"

void print_depl()
{
deflate_state ds;
deflate_state *s=&ds;
printf("size pointer=%u\n",(int)sizeof(void*));

printf("#define dsWSize         %u\n",(int)(((char*)&(s->w_size))-((char*)s)));
printf("#define dsWMask         %u\n",(int)(((char*)&(s->w_mask))-((char*)s)));
printf("#define dsWindow        %u\n",(int)(((char*)&(s->window))-((char*)s)));
printf("#define dsPrev          %u\n",(int)(((char*)&(s->prev))-((char*)s)));
printf("#define dsMatchLen      %u\n",(int)(((char*)&(s->match_length))-((char*)s)));
printf("#define dsPrevMatch     %u\n",(int)(((char*)&(s->prev_match))-((char*)s)));
printf("#define dsStrStart      %u\n",(int)(((char*)&(s->strstart))-((char*)s)));
printf("#define dsMatchStart    %u\n",(int)(((char*)&(s->match_start))-((char*)s)));
printf("#define dsLookahead     %u\n",(int)(((char*)&(s->lookahead))-((char*)s)));
printf("#define dsPrevLen       %u\n",(int)(((char*)&(s->prev_length))-((char*)s)));
printf("#define dsMaxChainLen   %u\n",(int)(((char*)&(s->max_chain_length))-((char*)s)));
printf("#define dsGoodMatch     %u\n",(int)(((char*)&(s->good_match))-((char*)s)));
printf("#define dsNiceMatch     %u\n",(int)(((char*)&(s->nice_match))-((char*)s)));
}
*/

#define dsWSize          68
#define dsWMask          76
#define dsWindow         80
#define dsPrev           96
#define dsMatchLen       144
#define dsPrevMatch      148
#define dsStrStart       156
#define dsMatchStart     160
#define dsLookahead      164
#define dsPrevLen        168
#define dsMaxChainLen    172
#define dsGoodMatch      188
#define dsNiceMatch      192

#define window_size      [ rcx + dsWSize]
#define WMask            [ rcx + dsWMask]
#define window_ad        [ rcx + dsWindow]
#define prev_ad          [ rcx + dsPrev]
#define strstart         [ rcx + dsStrStart]
#define match_start      [ rcx + dsMatchStart]
#define Lookahead        [ rcx + dsLookahead] //; 0ffffffffh on infozip
#define prev_length      [ rcx + dsPrevLen]
#define max_chain_length [ rcx + dsMaxChainLen]
#define good_match       [ rcx + dsGoodMatch]
#define nice_match       [ rcx + dsNiceMatch]

/*
; windows:
; parameter 1 in rcx(deflate state s), param 2 in rdx (cur match)

; see http://weblogs.asp.net/oldnewthing/archive/2004/01/14/58579.aspx and
; http://msdn.microsoft.com/library/en-us/kmarch/hh/kmarch/64bitAMD_8e951dd2-ee77-4728-8702-55ce4b5dd24a.xml.asp
;
; All registers must be preserved across the call, except for
;   rax, rcx, rdx, r8, r9, r10, and r11, which are scratch.

;
; gcc on macosx-linux:
; see http://www.x86-64.org/documentation/abi-0.99.pdf
; param 1 in rdi, param 2 in rsi
; rbx, rsp, rbp, r12 to r15 must be preserved

;;; Save registers that the compiler may be using, and adjust esp to
;;; make room for our stack frame.


;;; Retrieve the function arguments. r8d 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.

; ms: parameter 1 in rcx (deflate_state* s), param 2 in edx -> r8 (cur match)
; mac: param 1 in rdi, param 2 rsi
; this clear high 32 bits of r8, which can be garbage in both r8 and rdx
*/
        mov [save_rbx],rbx
        mov [save_rbp],rbp


        mov rcx,rdi

        mov r8d,esi


        mov [save_r12],r12
        mov [save_r13],r13
        mov [save_r14],r14
        mov [save_r15],r15


//;;; uInt wmask = s->w_mask;
//;;; unsigned chain_length = s->max_chain_length;
//;;; if (s->prev_length >= s->good_match) {
//;;;     chain_length >>= 2;
//;;; }


        mov edi, prev_length
        mov esi, good_match
        mov eax, WMask
        mov ebx, max_chain_length
        cmp edi, esi
        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

//;;; on zlib only
//;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;


        mov eax, nice_match
        mov [chainlenwmask], ebx
        mov r10d, Lookahead
        cmp r10d, eax
        cmovnl r10d, eax
        mov [nicematch],r10d


//;;; register Bytef *scan = s->window + s->strstart;
        mov r10, window_ad
        mov ebp, strstart
        lea r13, [r10 + rbp]

//;;; Determine how many bytes the scan ptr is off from being
//;;; dword-aligned.

         mov r9,r13
         neg r13
         and r13,3

//;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
//;;;     s->strstart - (IPos)MAX_DIST(s) : NIL;


        mov eax, window_size
        sub eax, MIN_LOOKAHEAD


        xor edi,edi
        sub ebp, eax

        mov r11d, prev_length

        cmovng ebp,edi

//;;; int best_len = s->prev_length;


//;;; Store the sum of s->window + best_len in esi locally, and in esi.

       lea  rsi,[r10+r11]

//;;; register ush scan_start = *(ushf*)scan;
//;;; register ush scan_end   = *(ushf*)(scan+best_len-1);
//;;; Posf *prev = s->prev;

        movzx r12d,word ptr [r9]
        movzx ebx, word ptr [r9 + r11 - 1]

        mov rdi, prev_ad

//;;; Jump into the main loop.

        mov edx, [chainlenwmask]

        cmp bx,word ptr [rsi + r8 - 1]
        jz  LookupLoopIsZero
                                
                                                
LookupLoop1:
        and r8d, edx

        movzx   r8d, word ptr [rdi + r8*2]
        cmp r8d, ebp
        jbe LeaveNow
                
                
        sub edx, 0x00010000
                BEFORE_JMP
        js  LeaveNow
                AFTER_JMP

LoopEntry1:
        cmp bx,word ptr [rsi + r8 - 1]
                BEFORE_JMP
        jz  LookupLoopIsZero
                AFTER_JMP

LookupLoop2:
        and r8d, edx

        movzx   r8d, word ptr [rdi + r8*2]
        cmp r8d, ebp
                BEFORE_JMP
        jbe LeaveNow
                AFTER_JMP
        sub edx, 0x00010000
                BEFORE_JMP
        js  LeaveNow
                AFTER_JMP

LoopEntry2:
        cmp bx,word ptr [rsi + r8 - 1]
                BEFORE_JMP
        jz  LookupLoopIsZero
                AFTER_JMP

LookupLoop4:
        and r8d, edx

        movzx   r8d, word ptr [rdi + r8*2]
        cmp r8d, ebp
                BEFORE_JMP
        jbe LeaveNow
                AFTER_JMP
        sub edx, 0x00010000
                BEFORE_JMP
        js  LeaveNow
                AFTER_JMP

LoopEntry4:

        cmp bx,word ptr [rsi + r8 - 1]
                BEFORE_JMP
        jnz LookupLoop1
        jmp LookupLoopIsZero
                AFTER_JMP
/*
;;; 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
;;; r8d = curmatch
;;; edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
;;; esi = windowbestlen - i.e., (window + bestlen)
;;; edi = prev
;;; ebp = limit
*/
.balign 16
LookupLoop:
        and r8d, edx

        movzx   r8d, word ptr [rdi + r8*2]
        cmp r8d, ebp
                BEFORE_JMP
        jbe LeaveNow
                AFTER_JMP
        sub edx, 0x00010000
                BEFORE_JMP
        js  LeaveNow
                AFTER_JMP

LoopEntry:

        cmp bx,word ptr [rsi + r8 - 1]
                BEFORE_JMP
        jnz LookupLoop1
                AFTER_JMP
LookupLoopIsZero:
        cmp     r12w, word ptr [r10 + r8]
                BEFORE_JMP
        jnz LookupLoop1
                AFTER_JMP


//;;; 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).
*/
        lea rsi,[r8+r10]
        mov rdx, 0xfffffffffffffef8 //; -(MAX_MATCH_8)
        lea rsi, [rsi + r13 + 0x0108] //;MAX_MATCH_8]
        lea rdi, [r9 + r13 + 0x0108] //;MAX_MATCH_8]

        prefetcht1 [rsi+rdx]
        prefetcht1 [rdi+rdx]

/*
;;; Test the strings for equality, 8 bytes at a time. At the end,
;;; adjust rdx 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. (rsi 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 rax, [rsi + rdx]
        xor rax, [rdi + rdx]
        jnz LeaveLoopCmps

        mov rax, [rsi + rdx + 8]
        xor rax, [rdi + rdx + 8]
        jnz LeaveLoopCmps8


        mov rax, [rsi + rdx + 8+8]
        xor rax, [rdi + rdx + 8+8]
        jnz LeaveLoopCmps16

        add rdx,8+8+8

                BEFORE_JMP
        jnz  LoopCmps
        jmp  LenMaximum
                AFTER_JMP
                
LeaveLoopCmps16: add rdx,8
LeaveLoopCmps8: add rdx,8
LeaveLoopCmps:

        test    eax, 0x0000FFFF
        jnz LenLower

        test eax,0xffffffff

        jnz LenLower32

        add rdx,4
        shr rax,32
        or ax,ax
                BEFORE_JMP
        jnz LenLower
                AFTER_JMP

LenLower32:
        shr eax,16
        add rdx,2
                
LenLower:               
        sub al, 1
        adc rdx, 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 rax, [rdi + rdx]
        sub rax, r9
        cmp eax, MAX_MATCH
                BEFORE_JMP
        jge LenMaximum
                AFTER_JMP
/*
;;; 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.
;///////////////////////////////////
*/
        cmp eax, r11d
        jg  LongerMatch

        lea rsi,[r10+r11]

        mov rdi, prev_ad
        mov edx, [chainlenwmask]
                BEFORE_JMP
        jmp LookupLoop
                AFTER_JMP
/*
;;;         s->match_start = cur_match;
;;;         best_len = len;
;;;         if (len >= nice_match) break;
;;;         scan_end = *(ushf*)(scan+best_len-1);
*/
LongerMatch:
        mov r11d, eax
        mov match_start, r8d
        cmp eax, [nicematch]
                BEFORE_JMP
        jge LeaveNow
                AFTER_JMP

        lea rsi,[r10+rax]

        movzx   ebx, word ptr [r9 + rax - 1]
        mov rdi, prev_ad
        mov edx, [chainlenwmask]
                BEFORE_JMP
        jmp LookupLoop
                AFTER_JMP

//;;; Accept the current string, with the maximum possible length.

LenMaximum:
        mov r11d,MAX_MATCH
        mov match_start, r8d

//;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
//;;; return s->lookahead;

LeaveNow:
        mov eax, Lookahead
        cmp r11d, eax
        cmovng eax, r11d


//;;; Restore the stack and return from whence we came.


//        mov rsi,[save_rsi]
//        mov rdi,[save_rdi]
        mov rbx,[save_rbx]
        mov rbp,[save_rbp]
        mov r12,[save_r12]
        mov r13,[save_r13]
        mov r14,[save_r14]
        mov r15,[save_r15]


        ret 0
//; please don't remove this string !
//; Your can freely use gvmat64 in any free or commercial app
//; but it is far better don't remove the string in the binary!
 //   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


match_init:
  ret 0


Revision:	1096
Committed:	Sat Dec 30 14:40:33 2017 UTC (7 years, 10 months ago) by s10k
File size:	16413 byte(s)
Log Message:	Added zlib, quazip, basicxmlsyntaxhighlighter, conditionalsemaphore and linenumberdisplay libraries. zlib and quazip are pre-compiled, but you can compile them yourself, just delete the dll files (or equivalent binary files to your OS)
#	Content
1	/*
2	;uInt longest_match_x64(
3	; deflate_state *s,
4	; IPos cur_match); // current match
5
6	; gvmat64.S -- Asm portion of the optimized longest_match for 32 bits x86_64
7	; (AMD64 on Athlon 64, Opteron, Phenom
8	; and Intel EM64T on Pentium 4 with EM64T, Pentium D, Core 2 Duo, Core I5/I7)
9	; this file is translation from gvmat64.asm to GCC 4.x (for Linux, Mac XCode)
10	; Copyright (C) 1995-2010 Jean-loup Gailly, Brian Raiter and Gilles Vollant.
11	;
12	; File written by Gilles Vollant, by converting to assembly the longest_match
13	; from Jean-loup Gailly in deflate.c of zLib and infoZip zip.
14	; and by taking inspiration on asm686 with masm, optimised assembly code
15	; from Brian Raiter, written 1998
16	;
17	; This software is provided 'as-is', without any express or implied
18	; warranty. In no event will the authors be held liable for any damages
19	; arising from the use of this software.
20	;
21	; Permission is granted to anyone to use this software for any purpose,
22	; including commercial applications, and to alter it and redistribute it
23	; freely, subject to the following restrictions:
24	;
25	; 1. The origin of this software must not be misrepresented; you must not
26	; claim that you wrote the original software. If you use this software
27	; in a product, an acknowledgment in the product documentation would be
28	; appreciated but is not required.
29	; 2. Altered source versions must be plainly marked as such, and must not be
30	; misrepresented as being the original software
31	; 3. This notice may not be removed or altered from any source distribution.
32	;
33	; http://www.zlib.net
34	; http://www.winimage.com/zLibDll
35	; http://www.muppetlabs.com/~breadbox/software/assembly.html
36	;
37	; to compile this file for zLib, I use option:
38	; gcc -c -arch x86_64 gvmat64.S
39
40
41	;uInt longest_match(s, cur_match)
42	; deflate_state *s;
43	; IPos cur_match; // current match /
44	;
45	; with XCode for Mac, I had strange error with some jump on intel syntax
46	; this is why BEFORE_JMP and AFTER_JMP are used
47	*/
48
49
50	#define BEFORE_JMP .att_syntax
51	#define AFTER_JMP .intel_syntax noprefix
52
53	#ifndef NO_UNDERLINE
54	# define match_init _match_init
55	# define longest_match _longest_match
56	#endif
57
58	.intel_syntax noprefix
59
60	.globl match_init, longest_match
61	.text
62	longest_match:
63
64
65
66	#define LocalVarsSize 96
67	/*
68	; register used : rax,rbx,rcx,rdx,rsi,rdi,r8,r9,r10,r11,r12
69	; free register : r14,r15
70	; register can be saved : rsp
71	*/
72
73	#define chainlenwmask (rsp + 8 - LocalVarsSize)
74	#define nicematch (rsp + 16 - LocalVarsSize)
75
76	#define save_rdi (rsp + 24 - LocalVarsSize)
77	#define save_rsi (rsp + 32 - LocalVarsSize)
78	#define save_rbx (rsp + 40 - LocalVarsSize)
79	#define save_rbp (rsp + 48 - LocalVarsSize)
80	#define save_r12 (rsp + 56 - LocalVarsSize)
81	#define save_r13 (rsp + 64 - LocalVarsSize)
82	#define save_r14 (rsp + 72 - LocalVarsSize)
83	#define save_r15 (rsp + 80 - LocalVarsSize)
84
85
86	/*
87	; all the +4 offsets are due to the addition of pending_buf_size (in zlib
88	; in the deflate_state structure since the asm code was first written
89	; (if you compile with zlib 1.0.4 or older, remove the +4).
90	; Note : these value are good with a 8 bytes boundary pack structure
91	*/
92
93	#define MAX_MATCH 258
94	#define MIN_MATCH 3
95	#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
96
97	/*
98	;;; Offsets for fields in the deflate_state structure. These numbers
99	;;; are calculated from the definition of deflate_state, with the
100	;;; assumption that the compiler will dword-align the fields. (Thus,
101	;;; changing the definition of deflate_state could easily cause this
102	;;; program to crash horribly, without so much as a warning at
103	;;; compile time. Sigh.)
104
105	; all the +zlib1222add offsets are due to the addition of fields
106	; in zlib in the deflate_state structure since the asm code was first written
107	; (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
108	; (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
109	; if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
110	*/
111
112
113
114	/* you can check the structure offset by running
115
116	#include <stdlib.h>
117	#include <stdio.h>
118	#include "deflate.h"
119
120	void print_depl()
121	{
122	deflate_state ds;
123	deflate_state *s=&ds;
124	printf("size pointer=%u\n",(int)sizeof(void*));
125
126	printf("#define dsWSize %u\n",(int)(((char)&(s->w_size))-((char)s)));
127	printf("#define dsWMask %u\n",(int)(((char)&(s->w_mask))-((char)s)));
128	printf("#define dsWindow %u\n",(int)(((char)&(s->window))-((char)s)));
129	printf("#define dsPrev %u\n",(int)(((char)&(s->prev))-((char)s)));
130	printf("#define dsMatchLen %u\n",(int)(((char)&(s->match_length))-((char)s)));
131	printf("#define dsPrevMatch %u\n",(int)(((char)&(s->prev_match))-((char)s)));
132	printf("#define dsStrStart %u\n",(int)(((char)&(s->strstart))-((char)s)));
133	printf("#define dsMatchStart %u\n",(int)(((char)&(s->match_start))-((char)s)));
134	printf("#define dsLookahead %u\n",(int)(((char)&(s->lookahead))-((char)s)));
135	printf("#define dsPrevLen %u\n",(int)(((char)&(s->prev_length))-((char)s)));
136	printf("#define dsMaxChainLen %u\n",(int)(((char)&(s->max_chain_length))-((char)s)));
137	printf("#define dsGoodMatch %u\n",(int)(((char)&(s->good_match))-((char)s)));
138	printf("#define dsNiceMatch %u\n",(int)(((char)&(s->nice_match))-((char)s)));
139	}
140	*/
141
142	#define dsWSize 68
143	#define dsWMask 76
144	#define dsWindow 80
145	#define dsPrev 96
146	#define dsMatchLen 144
147	#define dsPrevMatch 148
148	#define dsStrStart 156
149	#define dsMatchStart 160
150	#define dsLookahead 164
151	#define dsPrevLen 168
152	#define dsMaxChainLen 172
153	#define dsGoodMatch 188
154	#define dsNiceMatch 192
155
156	#define window_size [ rcx + dsWSize]
157	#define WMask [ rcx + dsWMask]
158	#define window_ad [ rcx + dsWindow]
159	#define prev_ad [ rcx + dsPrev]
160	#define strstart [ rcx + dsStrStart]
161	#define match_start [ rcx + dsMatchStart]
162	#define Lookahead [ rcx + dsLookahead] //; 0ffffffffh on infozip
163	#define prev_length [ rcx + dsPrevLen]
164	#define max_chain_length [ rcx + dsMaxChainLen]
165	#define good_match [ rcx + dsGoodMatch]
166	#define nice_match [ rcx + dsNiceMatch]
167
168	/*
169	; windows:
170	; parameter 1 in rcx(deflate state s), param 2 in rdx (cur match)
171
172	; see http://weblogs.asp.net/oldnewthing/archive/2004/01/14/58579.aspx and
173	; http://msdn.microsoft.com/library/en-us/kmarch/hh/kmarch/64bitAMD_8e951dd2-ee77-4728-8702-55ce4b5dd24a.xml.asp
174	;
175	; All registers must be preserved across the call, except for
176	; rax, rcx, rdx, r8, r9, r10, and r11, which are scratch.
177
178	;
179	; gcc on macosx-linux:
180	; see http://www.x86-64.org/documentation/abi-0.99.pdf
181	; param 1 in rdi, param 2 in rsi
182	; rbx, rsp, rbp, r12 to r15 must be preserved
183
184	;;; Save registers that the compiler may be using, and adjust esp to
185	;;; make room for our stack frame.
186
187
188	;;; Retrieve the function arguments. r8d will hold cur_match
189	;;; throughout the entire function. edx will hold the pointer to the
190	;;; deflate_state structure during the function's setup (before
191	;;; entering the main loop.
192
193	; ms: parameter 1 in rcx (deflate_state* s), param 2 in edx -> r8 (cur match)
194	; mac: param 1 in rdi, param 2 rsi
195	; this clear high 32 bits of r8, which can be garbage in both r8 and rdx
196	*/
197	mov [save_rbx],rbx
198	mov [save_rbp],rbp
199
200
201	mov rcx,rdi
202
203	mov r8d,esi
204
205
206	mov [save_r12],r12
207	mov [save_r13],r13
208	mov [save_r14],r14
209	mov [save_r15],r15
210
211
212	//;;; uInt wmask = s->w_mask;
213	//;;; unsigned chain_length = s->max_chain_length;
214	//;;; if (s->prev_length >= s->good_match) {
215	//;;; chain_length >>= 2;
216	//;;; }
217
218
219	mov edi, prev_length
220	mov esi, good_match
221	mov eax, WMask
222	mov ebx, max_chain_length
223	cmp edi, esi
224	jl LastMatchGood
225	shr ebx, 2
226	LastMatchGood:
227
228	//;;; chainlen is decremented once beforehand so that the function can
229	//;;; use the sign flag instead of the zero flag for the exit test.
230	//;;; It is then shifted into the high word, to make room for the wmask
231	//;;; value, which it will always accompany.
232
233	dec ebx
234	shl ebx, 16
235	or ebx, eax
236
237	//;;; on zlib only
238	//;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
239
240
241
242	mov eax, nice_match
243	mov [chainlenwmask], ebx
244	mov r10d, Lookahead
245	cmp r10d, eax
246	cmovnl r10d, eax
247	mov [nicematch],r10d
248
249
250
251	//;;; register Bytef *scan = s->window + s->strstart;
252	mov r10, window_ad
253	mov ebp, strstart
254	lea r13, [r10 + rbp]
255
256	//;;; Determine how many bytes the scan ptr is off from being
257	//;;; dword-aligned.
258
259	mov r9,r13
260	neg r13
261	and r13,3
262
263	//;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
264	//;;; s->strstart - (IPos)MAX_DIST(s) : NIL;
265
266
267	mov eax, window_size
268	sub eax, MIN_LOOKAHEAD
269
270
271	xor edi,edi
272	sub ebp, eax
273
274	mov r11d, prev_length
275
276	cmovng ebp,edi
277
278	//;;; int best_len = s->prev_length;
279
280
281	//;;; Store the sum of s->window + best_len in esi locally, and in esi.
282
283	lea rsi,[r10+r11]
284
285	//;;; register ush scan_start = (ushf)scan;
286	//;;; register ush scan_end = (ushf)(scan+best_len-1);
287	//;;; Posf *prev = s->prev;
288
289	movzx r12d,word ptr [r9]
290	movzx ebx, word ptr [r9 + r11 - 1]
291
292	mov rdi, prev_ad
293
294	//;;; Jump into the main loop.
295
296	mov edx, [chainlenwmask]
297
298	cmp bx,word ptr [rsi + r8 - 1]
299	jz LookupLoopIsZero
300
301
302
303	LookupLoop1:
304	and r8d, edx
305
306	movzx r8d, word ptr [rdi + r8*2]
307	cmp r8d, ebp
308	jbe LeaveNow
309
310
311
312	sub edx, 0x00010000
313	BEFORE_JMP
314	js LeaveNow
315	AFTER_JMP
316
317	LoopEntry1:
318	cmp bx,word ptr [rsi + r8 - 1]
319	BEFORE_JMP
320	jz LookupLoopIsZero
321	AFTER_JMP
322
323	LookupLoop2:
324	and r8d, edx
325
326	movzx r8d, word ptr [rdi + r8*2]
327	cmp r8d, ebp
328	BEFORE_JMP
329	jbe LeaveNow
330	AFTER_JMP
331	sub edx, 0x00010000
332	BEFORE_JMP
333	js LeaveNow
334	AFTER_JMP
335
336	LoopEntry2:
337	cmp bx,word ptr [rsi + r8 - 1]
338	BEFORE_JMP
339	jz LookupLoopIsZero
340	AFTER_JMP
341
342	LookupLoop4:
343	and r8d, edx
344
345	movzx r8d, word ptr [rdi + r8*2]
346	cmp r8d, ebp
347	BEFORE_JMP
348	jbe LeaveNow
349	AFTER_JMP
350	sub edx, 0x00010000
351	BEFORE_JMP
352	js LeaveNow
353	AFTER_JMP
354
355	LoopEntry4:
356
357	cmp bx,word ptr [rsi + r8 - 1]
358	BEFORE_JMP
359	jnz LookupLoop1
360	jmp LookupLoopIsZero
361	AFTER_JMP
362	/*
363	;;; do {
364	;;; match = s->window + cur_match;
365	;;; if ((ushf)(match+best_len-1) != scan_end \|\|
366	;;; (ushf)match != scan_start) continue;
367	;;; [...]
368	;;; } while ((cur_match = prev[cur_match & wmask]) > limit
369	;;; && --chain_length != 0);
370	;;;
371	;;; Here is the inner loop of the function. The function will spend the
372	;;; majority of its time in this loop, and majority of that time will
373	;;; be spent in the first ten instructions.
374	;;;
375	;;; Within this loop:
376	;;; ebx = scanend
377	;;; r8d = curmatch
378	;;; edx = chainlenwmask - i.e., ((chainlen << 16) \| wmask)
379	;;; esi = windowbestlen - i.e., (window + bestlen)
380	;;; edi = prev
381	;;; ebp = limit
382	*/
383	.balign 16
384	LookupLoop:
385	and r8d, edx
386
387	movzx r8d, word ptr [rdi + r8*2]
388	cmp r8d, ebp
389	BEFORE_JMP
390	jbe LeaveNow
391	AFTER_JMP
392	sub edx, 0x00010000
393	BEFORE_JMP
394	js LeaveNow
395	AFTER_JMP
396
397	LoopEntry:
398
399	cmp bx,word ptr [rsi + r8 - 1]
400	BEFORE_JMP
401	jnz LookupLoop1
402	AFTER_JMP
403	LookupLoopIsZero:
404	cmp r12w, word ptr [r10 + r8]
405	BEFORE_JMP
406	jnz LookupLoop1
407	AFTER_JMP
408
409
410	//;;; Store the current value of chainlen.
411	mov [chainlenwmask], edx
412	/*
413	;;; Point edi to the string under scrutiny, and esi to the string we
414	;;; are hoping to match it up with. In actuality, esi and edi are
415	;;; both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and edx is
416	;;; initialized to -(MAX_MATCH_8 - scanalign).
417	*/
418	lea rsi,[r8+r10]
419	mov rdx, 0xfffffffffffffef8 //; -(MAX_MATCH_8)
420	lea rsi, [rsi + r13 + 0x0108] //;MAX_MATCH_8]
421	lea rdi, [r9 + r13 + 0x0108] //;MAX_MATCH_8]
422
423	prefetcht1 [rsi+rdx]
424	prefetcht1 [rdi+rdx]
425
426	/*
427	;;; Test the strings for equality, 8 bytes at a time. At the end,
428	;;; adjust rdx so that it is offset to the exact byte that mismatched.
429	;;;
430	;;; We already know at this point that the first three bytes of the
431	;;; strings match each other, and they can be safely passed over before
432	;;; starting the compare loop. So what this code does is skip over 0-3
433	;;; bytes, as much as necessary in order to dword-align the edi
434	;;; pointer. (rsi will still be misaligned three times out of four.)
435	;;;
436	;;; It should be confessed that this loop usually does not represent
437	;;; much of the total running time. Replacing it with a more
438	;;; straightforward "rep cmpsb" would not drastically degrade
439	;;; performance.
440	*/
441
442	LoopCmps:
443	mov rax, [rsi + rdx]
444	xor rax, [rdi + rdx]
445	jnz LeaveLoopCmps
446
447	mov rax, [rsi + rdx + 8]
448	xor rax, [rdi + rdx + 8]
449	jnz LeaveLoopCmps8
450
451
452	mov rax, [rsi + rdx + 8+8]
453	xor rax, [rdi + rdx + 8+8]
454	jnz LeaveLoopCmps16
455
456	add rdx,8+8+8
457
458	BEFORE_JMP
459	jnz LoopCmps
460	jmp LenMaximum
461	AFTER_JMP
462
463	LeaveLoopCmps16: add rdx,8
464	LeaveLoopCmps8: add rdx,8
465	LeaveLoopCmps:
466
467	test eax, 0x0000FFFF
468	jnz LenLower
469
470	test eax,0xffffffff
471
472	jnz LenLower32
473
474	add rdx,4
475	shr rax,32
476	or ax,ax
477	BEFORE_JMP
478	jnz LenLower
479	AFTER_JMP
480
481	LenLower32:
482	shr eax,16
483	add rdx,2
484
485	LenLower:
486	sub al, 1
487	adc rdx, 0
488	//;;; Calculate the length of the match. If it is longer than MAX_MATCH,
489	//;;; then automatically accept it as the best possible match and leave.
490
491	lea rax, [rdi + rdx]
492	sub rax, r9
493	cmp eax, MAX_MATCH
494	BEFORE_JMP
495	jge LenMaximum
496	AFTER_JMP
497	/*
498	;;; If the length of the match is not longer than the best match we
499	;;; have so far, then forget it and return to the lookup loop.
500	;///////////////////////////////////
501	*/
502	cmp eax, r11d
503	jg LongerMatch
504
505	lea rsi,[r10+r11]
506
507	mov rdi, prev_ad
508	mov edx, [chainlenwmask]
509	BEFORE_JMP
510	jmp LookupLoop
511	AFTER_JMP
512	/*
513	;;; s->match_start = cur_match;
514	;;; best_len = len;
515	;;; if (len >= nice_match) break;
516	;;; scan_end = (ushf)(scan+best_len-1);
517	*/
518	LongerMatch:
519	mov r11d, eax
520	mov match_start, r8d
521	cmp eax, [nicematch]
522	BEFORE_JMP
523	jge LeaveNow
524	AFTER_JMP
525
526	lea rsi,[r10+rax]
527
528	movzx ebx, word ptr [r9 + rax - 1]
529	mov rdi, prev_ad
530	mov edx, [chainlenwmask]
531	BEFORE_JMP
532	jmp LookupLoop
533	AFTER_JMP
534
535	//;;; Accept the current string, with the maximum possible length.
536
537	LenMaximum:
538	mov r11d,MAX_MATCH
539	mov match_start, r8d
540
541	//;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
542	//;;; return s->lookahead;
543
544	LeaveNow:
545	mov eax, Lookahead
546	cmp r11d, eax
547	cmovng eax, r11d
548
549
550
551	//;;; Restore the stack and return from whence we came.
552
553
554	// mov rsi,[save_rsi]
555	// mov rdi,[save_rdi]
556	mov rbx,[save_rbx]
557	mov rbp,[save_rbp]
558	mov r12,[save_r12]
559	mov r13,[save_r13]
560	mov r14,[save_r14]
561	mov r15,[save_r15]
562
563
564	ret 0
565	//; please don't remove this string !
566	//; Your can freely use gvmat64 in any free or commercial app
567	//; but it is far better don't remove the string in the binary!
568	// 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
569
570
571	match_init:
572	ret 0
573
574