URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [zlib/] [contrib/] [masmx64/] [inffasx64.asm] - Blame information for rev 849

Go to most recent revision | Details | Compare with Previous | View Log


; inffasx64.asm is a hand tuned assembler version of inffast.c - fast decoding
; version for AMD64 on Windows using Microsoft C compiler
;
; inffasx64.asm is automatically convert from AMD64 portion of inffas86.c
; inffasx64.asm is called by inffas8664.c, which contain more info.
 
 
; to compile this file, I use option
;   ml64.exe /Flinffasx64 /c /Zi inffasx64.asm
;   with Microsoft Macro Assembler (x64) for AMD64
;
;   ml64.exe is given with Visual Studio 2005, Windows 2003 server DDK
;
;   (you can get Windows 2003 server DDK with ml64 and cl.exe for AMD64 from
;      http://www.microsoft.com/whdc/devtools/ddk/default.mspx for low price)
;
 
.code
inffas8664fnc PROC
 
; 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, r-9, r10, and r11, which are scratch.
 
 
        mov [rsp-8],rsi
        mov [rsp-16],rdi
        mov [rsp-24],r12
        mov [rsp-32],r13
        mov [rsp-40],r14
        mov [rsp-48],r15
        mov [rsp-56],rbx
 
        mov rax,rcx
 
        mov     [rax+8], rbp       ; /* save regs rbp and rsp */
        mov     [rax], rsp
 
        mov     rsp, rax          ; /* make rsp point to &ar */
 
        mov     rsi, [rsp+16]      ; /* rsi  = in */
        mov     rdi, [rsp+32]      ; /* rdi  = out */
        mov     r9, [rsp+24]       ; /* r9   = last */
        mov     r10, [rsp+48]      ; /* r10  = end */
        mov     rbp, [rsp+64]      ; /* rbp  = lcode */
        mov     r11, [rsp+72]      ; /* r11  = dcode */
        mov     rdx, [rsp+80]      ; /* rdx  = hold */
        mov     ebx, [rsp+88]      ; /* ebx  = bits */
        mov     r12d, [rsp+100]    ; /* r12d = lmask */
        mov     r13d, [rsp+104]    ; /* r13d = dmask */
                                          ; /* r14d = len */
                                          ; /* r15d = dist */
 
 
        cld
        cmp     r10, rdi
        je      L_one_time           ; /* if only one decode left */
        cmp     r9, rsi
 
    jne L_do_loop
 
 
L_one_time:
        mov     r8, r12           ; /* r8 = lmask */
        cmp     bl, 32
        ja      L_get_length_code_one_time
 
        lodsd                         ; /* eax = *(uint *)in++ */
        mov     cl, bl            ; /* cl = bits, needs it for shifting */
        add     bl, 32             ; /* bits += 32 */
        shl     rax, cl
        or      rdx, rax          ; /* hold |= *((uint *)in)++ << bits */
        jmp     L_get_length_code_one_time
 
ALIGN 4
L_while_test:
        cmp     r10, rdi
        jbe     L_break_loop
        cmp     r9, rsi
        jbe     L_break_loop
 
L_do_loop:
        mov     r8, r12           ; /* r8 = lmask */
        cmp     bl, 32
        ja      L_get_length_code    ; /* if (32 < bits) */
 
        lodsd                         ; /* eax = *(uint *)in++ */
        mov     cl, bl            ; /* cl = bits, needs it for shifting */
        add     bl, 32             ; /* bits += 32 */
        shl     rax, cl
        or      rdx, rax          ; /* hold |= *((uint *)in)++ << bits */
 
L_get_length_code:
        and     r8, rdx            ; /* r8 &= hold */
        mov     eax, [rbp+r8*4]  ; /* eax = lcode[hold & lmask] */
 
        mov     cl, ah            ; /* cl = this.bits */
        sub     bl, ah            ; /* bits -= this.bits */
        shr     rdx, cl           ; /* hold >>= this.bits */
 
        test    al, al
        jnz     L_test_for_length_base ; /* if (op != 0) 45.7% */
 
        mov     r8, r12            ; /* r8 = lmask */
        shr     eax, 16            ; /* output this.val char */
        stosb
 
L_get_length_code_one_time:
        and     r8, rdx            ; /* r8 &= hold */
        mov     eax, [rbp+r8*4] ; /* eax = lcode[hold & lmask] */
 
L_dolen:
        mov     cl, ah            ; /* cl = this.bits */
        sub     bl, ah            ; /* bits -= this.bits */
        shr     rdx, cl           ; /* hold >>= this.bits */
 
        test    al, al
        jnz     L_test_for_length_base ; /* if (op != 0) 45.7% */
 
        shr     eax, 16            ; /* output this.val char */
        stosb
        jmp     L_while_test
 
ALIGN 4
L_test_for_length_base:
        mov     r14d, eax         ; /* len = this */
        shr     r14d, 16           ; /* len = this.val */
        mov     cl, al
 
        test    al, 16
        jz      L_test_for_second_level_length ; /* if ((op & 16) == 0) 8% */
        and     cl, 15             ; /* op &= 15 */
        jz      L_decode_distance    ; /* if (!op) */
 
L_add_bits_to_len:
        sub     bl, cl
        xor     eax, eax
        inc     eax
        shl     eax, cl
        dec     eax
        and     eax, edx          ; /* eax &= hold */
        shr     rdx, cl
        add     r14d, eax         ; /* len += hold & mask[op] */
 
L_decode_distance:
        mov     r8, r13           ; /* r8 = dmask */
        cmp     bl, 32
        ja      L_get_distance_code  ; /* if (32 < bits) */
 
        lodsd                         ; /* eax = *(uint *)in++ */
        mov     cl, bl            ; /* cl = bits, needs it for shifting */
        add     bl, 32             ; /* bits += 32 */
        shl     rax, cl
        or      rdx, rax          ; /* hold |= *((uint *)in)++ << bits */
 
L_get_distance_code:
        and     r8, rdx           ; /* r8 &= hold */
        mov     eax, [r11+r8*4] ; /* eax = dcode[hold & dmask] */
 
L_dodist:
        mov     r15d, eax         ; /* dist = this */
        shr     r15d, 16           ; /* dist = this.val */
        mov     cl, ah
        sub     bl, ah            ; /* bits -= this.bits */
        shr     rdx, cl           ; /* hold >>= this.bits */
        mov     cl, al            ; /* cl = this.op */
 
        test    al, 16             ; /* if ((op & 16) == 0) */
        jz      L_test_for_second_level_dist
        and     cl, 15             ; /* op &= 15 */
        jz      L_check_dist_one
 
L_add_bits_to_dist:
        sub     bl, cl
        xor     eax, eax
        inc     eax
        shl     eax, cl
        dec     eax                 ; /* (1 << op) - 1 */
        and     eax, edx          ; /* eax &= hold */
        shr     rdx, cl
        add     r15d, eax         ; /* dist += hold & ((1 << op) - 1) */
 
L_check_window:
        mov     r8, rsi           ; /* save in so from can use it's reg */
        mov     rax, rdi
        sub     rax, [rsp+40]      ; /* nbytes = out - beg */
 
        cmp     eax, r15d
        jb      L_clip_window        ; /* if (dist > nbytes) 4.2% */
 
        mov     ecx, r14d         ; /* ecx = len */
        mov     rsi, rdi
        sub     rsi, r15          ; /* from = out - dist */
 
        sar     ecx, 1
        jnc     L_copy_two           ; /* if len % 2 == 0 */
 
        rep     movsw
        mov     al, [rsi]
        mov     [rdi], al
        inc     rdi
 
        mov     rsi, r8           ; /* move in back to %rsi, toss from */
        jmp     L_while_test
 
L_copy_two:
        rep     movsw
        mov     rsi, r8           ; /* move in back to %rsi, toss from */
        jmp     L_while_test
 
ALIGN 4
L_check_dist_one:
        cmp     r15d, 1            ; /* if dist 1, is a memset */
        jne     L_check_window
        cmp     [rsp+40], rdi      ; /* if out == beg, outside window */
        je      L_check_window
 
        mov     ecx, r14d         ; /* ecx = len */
        mov     al, [rdi-1]
        mov     ah, al
 
        sar     ecx, 1
        jnc     L_set_two
        mov     [rdi], al
        inc     rdi
 
L_set_two:
        rep     stosw
        jmp     L_while_test
 
ALIGN 4
L_test_for_second_level_length:
        test    al, 64
        jnz     L_test_for_end_of_block ; /* if ((op & 64) != 0) */
 
        xor     eax, eax
        inc     eax
        shl     eax, cl
        dec     eax
        and     eax, edx         ; /* eax &= hold */
        add     eax, r14d        ; /* eax += len */
        mov     eax, [rbp+rax*4] ; /* eax = lcode[val+(hold&mask[op])]*/
        jmp     L_dolen
 
ALIGN 4
L_test_for_second_level_dist:
        test    al, 64
        jnz     L_invalid_distance_code ; /* if ((op & 64) != 0) */
 
        xor     eax, eax
        inc     eax
        shl     eax, cl
        dec     eax
        and     eax, edx         ; /* eax &= hold */
        add     eax, r15d        ; /* eax += dist */
        mov     eax, [r11+rax*4] ; /* eax = dcode[val+(hold&mask[op])]*/
        jmp     L_dodist
 
ALIGN 4
L_clip_window:
        mov     ecx, eax         ; /* ecx = nbytes */
        mov     eax, [rsp+92]     ; /* eax = wsize, prepare for dist cmp */
        neg     ecx                ; /* nbytes = -nbytes */
 
        cmp     eax, r15d
        jb      L_invalid_distance_too_far ; /* if (dist > wsize) */
 
        add     ecx, r15d         ; /* nbytes = dist - nbytes */
        cmp     dword ptr [rsp+96], 0
        jne     L_wrap_around_window ; /* if (write != 0) */
 
        mov     rsi, [rsp+56]     ; /* from  = window */
        sub     eax, ecx         ; /* eax  -= nbytes */
        add     rsi, rax         ; /* from += wsize - nbytes */
 
        mov     eax, r14d        ; /* eax = len */
        cmp     r14d, ecx
        jbe     L_do_copy           ; /* if (nbytes >= len) */
 
        sub     eax, ecx         ; /* eax -= nbytes */
        rep     movsb
        mov     rsi, rdi
        sub     rsi, r15         ; /* from = &out[ -dist ] */
        jmp     L_do_copy
 
ALIGN 4
L_wrap_around_window:
        mov     eax, [rsp+96]     ; /* eax = write */
        cmp     ecx, eax
        jbe     L_contiguous_in_window ; /* if (write >= nbytes) */
 
        mov     esi, [rsp+92]     ; /* from  = wsize */
        add     rsi, [rsp+56]     ; /* from += window */
        add     rsi, rax         ; /* from += write */
        sub     rsi, rcx         ; /* from -= nbytes */
        sub     ecx, eax         ; /* nbytes -= write */
 
        mov     eax, r14d        ; /* eax = len */
        cmp     eax, ecx
        jbe     L_do_copy           ; /* if (nbytes >= len) */
 
        sub     eax, ecx         ; /* len -= nbytes */
        rep     movsb
        mov     rsi, [rsp+56]     ; /* from = window */
        mov     ecx, [rsp+96]     ; /* nbytes = write */
        cmp     eax, ecx
        jbe     L_do_copy           ; /* if (nbytes >= len) */
 
        sub     eax, ecx         ; /* len -= nbytes */
        rep     movsb
        mov     rsi, rdi
        sub     rsi, r15         ; /* from = out - dist */
        jmp     L_do_copy
 
ALIGN 4
L_contiguous_in_window:
        mov     rsi, [rsp+56]     ; /* rsi = window */
        add     rsi, rax
        sub     rsi, rcx         ; /* from += write - nbytes */
 
        mov     eax, r14d        ; /* eax = len */
        cmp     eax, ecx
        jbe     L_do_copy           ; /* if (nbytes >= len) */
 
        sub     eax, ecx         ; /* len -= nbytes */
        rep     movsb
        mov     rsi, rdi
        sub     rsi, r15         ; /* from = out - dist */
        jmp     L_do_copy           ; /* if (nbytes >= len) */
 
ALIGN 4
L_do_copy:
        mov     ecx, eax         ; /* ecx = len */
        rep     movsb
 
        mov     rsi, r8          ; /* move in back to %esi, toss from */
        jmp     L_while_test
 
L_test_for_end_of_block:
        test    al, 32
        jz      L_invalid_literal_length_code
        mov     dword ptr [rsp+116], 1
        jmp     L_break_loop_with_status
 
L_invalid_literal_length_code:
        mov     dword ptr [rsp+116], 2
        jmp     L_break_loop_with_status
 
L_invalid_distance_code:
        mov     dword ptr [rsp+116], 3
        jmp     L_break_loop_with_status
 
L_invalid_distance_too_far:
        mov     dword ptr [rsp+116], 4
        jmp     L_break_loop_with_status
 
L_break_loop:
        mov     dword ptr [rsp+116], 0
 
L_break_loop_with_status:
; /* put in, out, bits, and hold back into ar and pop esp */
        mov     [rsp+16], rsi     ; /* in */
        mov     [rsp+32], rdi     ; /* out */
        mov     [rsp+88], ebx     ; /* bits */
        mov     [rsp+80], rdx     ; /* hold */
 
        mov     rax, [rsp]       ; /* restore rbp and rsp */
        mov     rbp, [rsp+8]
        mov     rsp, rax
 
 
 
        mov rsi,[rsp-8]
        mov rdi,[rsp-16]
        mov r12,[rsp-24]
        mov r13,[rsp-32]
        mov r14,[rsp-40]
        mov r15,[rsp-48]
        mov rbx,[rsp-56]
 
    ret 0
;          :
;          : "m" (ar)
;          : "memory", "%rax", "%rbx", "%rcx", "%rdx", "%rsi", "%rdi",
;            "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
;    );
 
inffas8664fnc   ENDP
;_TEXT  ENDS
END

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [zlib/] [contrib/] [masmx64/] [inffasx64.asm] - Blame information for rev 849

Line No.	Rev	Author	Line
1	745	jeremybenn	`; inffasx64.asm is a hand tuned assembler version of inffast.c - fast decoding`
2			`; version for AMD64 on Windows using Microsoft C compiler`
3			`;`
4			`; inffasx64.asm is automatically convert from AMD64 portion of inffas86.c`
5			`; inffasx64.asm is called by inffas8664.c, which contain more info.`
6
7
8			`; to compile this file, I use option`
9			`; ml64.exe /Flinffasx64 /c /Zi inffasx64.asm`
10			`; with Microsoft Macro Assembler (x64) for AMD64`
11			`;`
12			`; ml64.exe is given with Visual Studio 2005, Windows 2003 server DDK`
13			`;`
14			`; (you can get Windows 2003 server DDK with ml64 and cl.exe for AMD64 from`
15			`; http://www.microsoft.com/whdc/devtools/ddk/default.mspx for low price)`
16			`;`
17
18			`.code`
19			`inffas8664fnc PROC`
20
21			`; see http://weblogs.asp.net/oldnewthing/archive/2004/01/14/58579.aspx and`
22			`; http://msdn.microsoft.com/library/en-us/kmarch/hh/kmarch/64bitAMD_8e951dd2-ee77-4728-8702-55ce4b5dd24a.xml.asp`
23			`;`
24			`; All registers must be preserved across the call, except for`
25			`; rax, rcx, rdx, r8, r-9, r10, and r11, which are scratch.`
26
27
28			`mov [rsp-8],rsi`
29			`mov [rsp-16],rdi`
30			`mov [rsp-24],r12`
31			`mov [rsp-32],r13`
32			`mov [rsp-40],r14`
33			`mov [rsp-48],r15`
34			`mov [rsp-56],rbx`
35
36			`mov rax,rcx`
37
38			`mov [rax+8], rbp ; /* save regs rbp and rsp */`
39			`mov [rax], rsp`
40
41			`mov rsp, rax ; /* make rsp point to &ar */`
42
43			`mov rsi, [rsp+16] ; /* rsi = in */`
44			`mov rdi, [rsp+32] ; /* rdi = out */`
45			`mov r9, [rsp+24] ; /* r9 = last */`
46			`mov r10, [rsp+48] ; /* r10 = end */`
47			`mov rbp, [rsp+64] ; /* rbp = lcode */`
48			`mov r11, [rsp+72] ; /* r11 = dcode */`
49			`mov rdx, [rsp+80] ; /* rdx = hold */`
50			`mov ebx, [rsp+88] ; /* ebx = bits */`
51			`mov r12d, [rsp+100] ; /* r12d = lmask */`
52			`mov r13d, [rsp+104] ; /* r13d = dmask */`
53			`; /* r14d = len */`
54			`; /* r15d = dist */`
55
56
57			`cld`
58			`cmp r10, rdi`
59			`je L_one_time ; /* if only one decode left */`
60			`cmp r9, rsi`
61
62			`jne L_do_loop`
63
64
65			`L_one_time:`
66			`mov r8, r12 ; /* r8 = lmask */`
67			`cmp bl, 32`
68			`ja L_get_length_code_one_time`
69
70			`lodsd ; /* eax = (uint )in++ */`
71			`mov cl, bl ; /* cl = bits, needs it for shifting */`
72			`add bl, 32 ; /* bits += 32 */`
73			`shl rax, cl`
74			`or rdx, rax ; /* hold \|= ((uint )in)++ << bits */`
75			`jmp L_get_length_code_one_time`
76
77			`ALIGN 4`
78			`L_while_test:`
79			`cmp r10, rdi`
80			`jbe L_break_loop`
81			`cmp r9, rsi`
82			`jbe L_break_loop`
83
84			`L_do_loop:`
85			`mov r8, r12 ; /* r8 = lmask */`
86			`cmp bl, 32`
87			`ja L_get_length_code ; /* if (32 < bits) */`
88
89			`lodsd ; /* eax = (uint )in++ */`
90			`mov cl, bl ; /* cl = bits, needs it for shifting */`
91			`add bl, 32 ; /* bits += 32 */`
92			`shl rax, cl`
93			`or rdx, rax ; /* hold \|= ((uint )in)++ << bits */`
94
95			`L_get_length_code:`
96			`and r8, rdx ; /* r8 &= hold */`
97			`mov eax, [rbp+r84] ; / eax = lcode[hold & lmask] */`
98
99			`mov cl, ah ; /* cl = this.bits */`
100			`sub bl, ah ; /* bits -= this.bits */`
101			`shr rdx, cl ; /* hold >>= this.bits */`
102
103			`test al, al`
104			`jnz L_test_for_length_base ; /* if (op != 0) 45.7% */`
105
106			`mov r8, r12 ; /* r8 = lmask */`
107			`shr eax, 16 ; /* output this.val char */`
108			`stosb`
109
110			`L_get_length_code_one_time:`
111			`and r8, rdx ; /* r8 &= hold */`
112			`mov eax, [rbp+r84] ; / eax = lcode[hold & lmask] */`
113
114			`L_dolen:`
115			`mov cl, ah ; /* cl = this.bits */`
116			`sub bl, ah ; /* bits -= this.bits */`
117			`shr rdx, cl ; /* hold >>= this.bits */`
118
119			`test al, al`
120			`jnz L_test_for_length_base ; /* if (op != 0) 45.7% */`
121
122			`shr eax, 16 ; /* output this.val char */`
123			`stosb`
124			`jmp L_while_test`
125
126			`ALIGN 4`
127			`L_test_for_length_base:`
128			`mov r14d, eax ; /* len = this */`
129			`shr r14d, 16 ; /* len = this.val */`
130			`mov cl, al`
131
132			`test al, 16`
133			`jz L_test_for_second_level_length ; /* if ((op & 16) == 0) 8% */`
134			`and cl, 15 ; /* op &= 15 */`
135			`jz L_decode_distance ; /* if (!op) */`
136
137			`L_add_bits_to_len:`
138			`sub bl, cl`
139			`xor eax, eax`
140			`inc eax`
141			`shl eax, cl`
142			`dec eax`
143			`and eax, edx ; /* eax &= hold */`
144			`shr rdx, cl`
145			`add r14d, eax ; /* len += hold & mask[op] */`
146
147			`L_decode_distance:`
148			`mov r8, r13 ; /* r8 = dmask */`
149			`cmp bl, 32`
150			`ja L_get_distance_code ; /* if (32 < bits) */`
151
152			`lodsd ; /* eax = (uint )in++ */`
153			`mov cl, bl ; /* cl = bits, needs it for shifting */`
154			`add bl, 32 ; /* bits += 32 */`
155			`shl rax, cl`
156			`or rdx, rax ; /* hold \|= ((uint )in)++ << bits */`
157
158			`L_get_distance_code:`
159			`and r8, rdx ; /* r8 &= hold */`
160			`mov eax, [r11+r84] ; / eax = dcode[hold & dmask] */`
161
162			`L_dodist:`
163			`mov r15d, eax ; /* dist = this */`
164			`shr r15d, 16 ; /* dist = this.val */`
165			`mov cl, ah`
166			`sub bl, ah ; /* bits -= this.bits */`
167			`shr rdx, cl ; /* hold >>= this.bits */`
168			`mov cl, al ; /* cl = this.op */`
169
170			`test al, 16 ; /* if ((op & 16) == 0) */`
171			`jz L_test_for_second_level_dist`
172			`and cl, 15 ; /* op &= 15 */`
173			`jz L_check_dist_one`
174
175			`L_add_bits_to_dist:`
176			`sub bl, cl`
177			`xor eax, eax`
178			`inc eax`
179			`shl eax, cl`
180			`dec eax ; /* (1 << op) - 1 */`
181			`and eax, edx ; /* eax &= hold */`
182			`shr rdx, cl`
183			`add r15d, eax ; /* dist += hold & ((1 << op) - 1) */`
184
185			`L_check_window:`
186			`mov r8, rsi ; /* save in so from can use it's reg */`
187			`mov rax, rdi`
188			`sub rax, [rsp+40] ; /* nbytes = out - beg */`
189
190			`cmp eax, r15d`
191			`jb L_clip_window ; /* if (dist > nbytes) 4.2% */`
192
193			`mov ecx, r14d ; /* ecx = len */`
194			`mov rsi, rdi`
195			`sub rsi, r15 ; /* from = out - dist */`
196
197			`sar ecx, 1`
198			`jnc L_copy_two ; /* if len % 2 == 0 */`
199
200			`rep movsw`
201			`mov al, [rsi]`
202			`mov [rdi], al`
203			`inc rdi`
204
205			`mov rsi, r8 ; /* move in back to %rsi, toss from */`
206			`jmp L_while_test`
207
208			`L_copy_two:`
209			`rep movsw`
210			`mov rsi, r8 ; /* move in back to %rsi, toss from */`
211			`jmp L_while_test`
212
213			`ALIGN 4`
214			`L_check_dist_one:`
215			`cmp r15d, 1 ; /* if dist 1, is a memset */`
216			`jne L_check_window`
217			`cmp [rsp+40], rdi ; /* if out == beg, outside window */`
218			`je L_check_window`
219
220			`mov ecx, r14d ; /* ecx = len */`
221			`mov al, [rdi-1]`
222			`mov ah, al`
223
224			`sar ecx, 1`
225			`jnc L_set_two`
226			`mov [rdi], al`
227			`inc rdi`
228
229			`L_set_two:`
230			`rep stosw`
231			`jmp L_while_test`
232
233			`ALIGN 4`
234			`L_test_for_second_level_length:`
235			`test al, 64`
236			`jnz L_test_for_end_of_block ; /* if ((op & 64) != 0) */`
237
238			`xor eax, eax`
239			`inc eax`
240			`shl eax, cl`
241			`dec eax`
242			`and eax, edx ; /* eax &= hold */`
243			`add eax, r14d ; /* eax += len */`
244			`mov eax, [rbp+rax4] ; / eax = lcode[val+(hold&mask[op])]*/`
245			`jmp L_dolen`
246
247			`ALIGN 4`
248			`L_test_for_second_level_dist:`
249			`test al, 64`
250			`jnz L_invalid_distance_code ; /* if ((op & 64) != 0) */`
251
252			`xor eax, eax`
253			`inc eax`
254			`shl eax, cl`
255			`dec eax`
256			`and eax, edx ; /* eax &= hold */`
257			`add eax, r15d ; /* eax += dist */`
258			`mov eax, [r11+rax4] ; / eax = dcode[val+(hold&mask[op])]*/`
259			`jmp L_dodist`
260
261			`ALIGN 4`
262			`L_clip_window:`
263			`mov ecx, eax ; /* ecx = nbytes */`
264			`mov eax, [rsp+92] ; /* eax = wsize, prepare for dist cmp */`
265			`neg ecx ; /* nbytes = -nbytes */`
266
267			`cmp eax, r15d`
268			`jb L_invalid_distance_too_far ; /* if (dist > wsize) */`
269
270			`add ecx, r15d ; /* nbytes = dist - nbytes */`
271			`cmp dword ptr [rsp+96], 0`
272			`jne L_wrap_around_window ; /* if (write != 0) */`
273
274			`mov rsi, [rsp+56] ; /* from = window */`
275			`sub eax, ecx ; /* eax -= nbytes */`
276			`add rsi, rax ; /* from += wsize - nbytes */`
277
278			`mov eax, r14d ; /* eax = len */`
279			`cmp r14d, ecx`
280			`jbe L_do_copy ; /* if (nbytes >= len) */`
281
282			`sub eax, ecx ; /* eax -= nbytes */`
283			`rep movsb`
284			`mov rsi, rdi`
285			`sub rsi, r15 ; /* from = &out[ -dist ] */`
286			`jmp L_do_copy`
287
288			`ALIGN 4`
289			`L_wrap_around_window:`
290			`mov eax, [rsp+96] ; /* eax = write */`
291			`cmp ecx, eax`
292			`jbe L_contiguous_in_window ; /* if (write >= nbytes) */`
293
294			`mov esi, [rsp+92] ; /* from = wsize */`
295			`add rsi, [rsp+56] ; /* from += window */`
296			`add rsi, rax ; /* from += write */`
297			`sub rsi, rcx ; /* from -= nbytes */`
298			`sub ecx, eax ; /* nbytes -= write */`
299
300			`mov eax, r14d ; /* eax = len */`
301			`cmp eax, ecx`
302			`jbe L_do_copy ; /* if (nbytes >= len) */`
303
304			`sub eax, ecx ; /* len -= nbytes */`
305			`rep movsb`
306			`mov rsi, [rsp+56] ; /* from = window */`
307			`mov ecx, [rsp+96] ; /* nbytes = write */`
308			`cmp eax, ecx`
309			`jbe L_do_copy ; /* if (nbytes >= len) */`
310
311			`sub eax, ecx ; /* len -= nbytes */`
312			`rep movsb`
313			`mov rsi, rdi`
314			`sub rsi, r15 ; /* from = out - dist */`
315			`jmp L_do_copy`
316
317			`ALIGN 4`
318			`L_contiguous_in_window:`
319			`mov rsi, [rsp+56] ; /* rsi = window */`
320			`add rsi, rax`
321			`sub rsi, rcx ; /* from += write - nbytes */`
322
323			`mov eax, r14d ; /* eax = len */`
324			`cmp eax, ecx`
325			`jbe L_do_copy ; /* if (nbytes >= len) */`
326
327			`sub eax, ecx ; /* len -= nbytes */`
328			`rep movsb`
329			`mov rsi, rdi`
330			`sub rsi, r15 ; /* from = out - dist */`
331			`jmp L_do_copy ; /* if (nbytes >= len) */`
332
333			`ALIGN 4`
334			`L_do_copy:`
335			`mov ecx, eax ; /* ecx = len */`
336			`rep movsb`
337
338			`mov rsi, r8 ; /* move in back to %esi, toss from */`
339			`jmp L_while_test`
340
341			`L_test_for_end_of_block:`
342			`test al, 32`
343			`jz L_invalid_literal_length_code`
344			`mov dword ptr [rsp+116], 1`
345			`jmp L_break_loop_with_status`
346
347			`L_invalid_literal_length_code:`
348			`mov dword ptr [rsp+116], 2`
349			`jmp L_break_loop_with_status`
350
351			`L_invalid_distance_code:`
352			`mov dword ptr [rsp+116], 3`
353			`jmp L_break_loop_with_status`
354
355			`L_invalid_distance_too_far:`
356			`mov dword ptr [rsp+116], 4`
357			`jmp L_break_loop_with_status`
358
359			`L_break_loop:`
360			`mov dword ptr [rsp+116], 0`
361
362			`L_break_loop_with_status:`
363			`; /* put in, out, bits, and hold back into ar and pop esp */`
364			`mov [rsp+16], rsi ; /* in */`
365			`mov [rsp+32], rdi ; /* out */`
366			`mov [rsp+88], ebx ; /* bits */`
367			`mov [rsp+80], rdx ; /* hold */`
368
369			`mov rax, [rsp] ; /* restore rbp and rsp */`
370			`mov rbp, [rsp+8]`
371			`mov rsp, rax`
372
373
374
375			`mov rsi,[rsp-8]`
376			`mov rdi,[rsp-16]`
377			`mov r12,[rsp-24]`
378			`mov r13,[rsp-32]`
379			`mov r14,[rsp-40]`
380			`mov r15,[rsp-48]`
381			`mov rbx,[rsp-56]`
382
383			`ret 0`
384			`; :`
385			`; : "m" (ar)`
386			`; : "memory", "%rax", "%rbx", "%rcx", "%rdx", "%rsi", "%rdi",`
387			`; "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"`
388			`; );`
389
390			`inffas8664fnc ENDP`
391			`;_TEXT ENDS`
392			`END`