diff options
Diffstat (limited to 'contrib/inflate86/inffas86.c')
-rw-r--r-- | contrib/inflate86/inffas86.c | 783 |
1 files changed, 783 insertions, 0 deletions
diff --git a/contrib/inflate86/inffas86.c b/contrib/inflate86/inffas86.c new file mode 100644 index 0000000..4534693 --- /dev/null +++ b/contrib/inflate86/inffas86.c | |||
@@ -0,0 +1,783 @@ | |||
1 | /* inffas86.c is a hand tuned assembler version of | ||
2 | * | ||
3 | * inffast.c -- fast decoding | ||
4 | * Copyright (C) 1995-2003 Mark Adler | ||
5 | * For conditions of distribution and use, see copyright notice in zlib.h | ||
6 | * | ||
7 | * Copyright (C) 2003 Chris Anderson <christop@charm.net> | ||
8 | * Please use the copyright conditions above. | ||
9 | * | ||
10 | * Mar-13-2003 -- Most of this is derived from inffast.S which is derived from | ||
11 | * the gcc -S output of zlib-1.2.0/inffast.c. Zlib-1.2.0 is in beta release at | ||
12 | * the moment. I have successfully compiled and tested this code with gcc2.96, | ||
13 | * gcc3.2, icc5.0, msvc6.0. It is very close to the speed of inffast.S | ||
14 | * compiled with gcc -DNO_MMX, but inffast.S is still faster on the P3 with MMX | ||
15 | * enabled. I will attempt to merge the MMX code into this version. Newer | ||
16 | * versions of this and inffast.S can be found at | ||
17 | * http://www.eetbeetee.com/zlib/ and http://www.charm.net/~christop/zlib/ | ||
18 | */ | ||
19 | |||
20 | #include "zutil.h" | ||
21 | #include "inftrees.h" | ||
22 | #include "inflate.h" | ||
23 | #include "inffast.h" | ||
24 | |||
25 | /* Mark Adler's comments from inffast.c: */ | ||
26 | |||
27 | /* | ||
28 | Decode literal, length, and distance codes and write out the resulting | ||
29 | literal and match bytes until either not enough input or output is | ||
30 | available, an end-of-block is encountered, or a data error is encountered. | ||
31 | When large enough input and output buffers are supplied to inflate(), for | ||
32 | example, a 16K input buffer and a 64K output buffer, more than 95% of the | ||
33 | inflate execution time is spent in this routine. | ||
34 | |||
35 | Entry assumptions: | ||
36 | |||
37 | state->mode == LEN | ||
38 | strm->avail_in >= 6 | ||
39 | strm->avail_out >= 258 | ||
40 | start >= strm->avail_out | ||
41 | state->bits < 8 | ||
42 | |||
43 | On return, state->mode is one of: | ||
44 | |||
45 | LEN -- ran out of enough output space or enough available input | ||
46 | TYPE -- reached end of block code, inflate() to interpret next block | ||
47 | BAD -- error in block data | ||
48 | |||
49 | Notes: | ||
50 | |||
51 | - The maximum input bits used by a length/distance pair is 15 bits for the | ||
52 | length code, 5 bits for the length extra, 15 bits for the distance code, | ||
53 | and 13 bits for the distance extra. This totals 48 bits, or six bytes. | ||
54 | Therefore if strm->avail_in >= 6, then there is enough input to avoid | ||
55 | checking for available input while decoding. | ||
56 | |||
57 | - The maximum bytes that a single length/distance pair can output is 258 | ||
58 | bytes, which is the maximum length that can be coded. inflate_fast() | ||
59 | requires strm->avail_out >= 258 for each loop to avoid checking for | ||
60 | output space. | ||
61 | */ | ||
62 | void inflate_fast(strm, start) | ||
63 | z_streamp strm; | ||
64 | unsigned start; /* inflate()'s starting value for strm->avail_out */ | ||
65 | { | ||
66 | struct inflate_state FAR *state; | ||
67 | struct inffast_ar { | ||
68 | void *esp; /* esp save */ | ||
69 | unsigned char FAR *in; /* local strm->next_in */ | ||
70 | unsigned char FAR *last; /* while in < last, enough input available */ | ||
71 | unsigned char FAR *out; /* local strm->next_out */ | ||
72 | unsigned char FAR *beg; /* inflate()'s initial strm->next_out */ | ||
73 | unsigned char FAR *end; /* while out < end, enough space available */ | ||
74 | unsigned wsize; /* window size or zero if not using window */ | ||
75 | unsigned write; /* window write index */ | ||
76 | unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */ | ||
77 | unsigned long hold; /* local strm->hold */ | ||
78 | unsigned bits; /* local strm->bits */ | ||
79 | code const FAR *lcode; /* local strm->lencode */ | ||
80 | code const FAR *dcode; /* local strm->distcode */ | ||
81 | unsigned lmask; /* mask for first level of length codes */ | ||
82 | unsigned dmask; /* mask for first level of distance codes */ | ||
83 | unsigned len; /* match length, unused bytes */ | ||
84 | unsigned dist; /* match distance */ | ||
85 | unsigned status; /* this is set when state changes */ | ||
86 | } ar; | ||
87 | |||
88 | /* copy state to local variables */ | ||
89 | state = (struct inflate_state FAR *)strm->state; | ||
90 | ar.in = strm->next_in; | ||
91 | ar.last = ar.in + (strm->avail_in - 5); | ||
92 | ar.out = strm->next_out; | ||
93 | ar.beg = ar.out - (start - strm->avail_out); | ||
94 | ar.end = ar.out + (strm->avail_out - 257); | ||
95 | ar.wsize = state->wsize; | ||
96 | ar.write = state->write; | ||
97 | ar.window = state->window; | ||
98 | ar.hold = state->hold; | ||
99 | ar.bits = state->bits; | ||
100 | ar.lcode = state->lencode; | ||
101 | ar.dcode = state->distcode; | ||
102 | ar.lmask = (1U << state->lenbits) - 1; | ||
103 | ar.dmask = (1U << state->distbits) - 1; | ||
104 | |||
105 | /* decode literals and length/distances until end-of-block or not enough | ||
106 | input data or output space */ | ||
107 | |||
108 | /* align in on 2 byte boundary */ | ||
109 | if (((unsigned long)(void *)ar.in & 0x1) != 0) { | ||
110 | ar.hold += (unsigned long)*ar.in++ << ar.bits; | ||
111 | ar.bits += 8; | ||
112 | } | ||
113 | |||
114 | #if defined( __GNUC__ ) || defined( __ICC ) | ||
115 | __asm__ __volatile__ ( | ||
116 | " leal %0, %%eax\n" | ||
117 | " pushf\n" | ||
118 | " pushl %%ebp\n" | ||
119 | " movl %%esp, (%%eax)\n" | ||
120 | " movl %%eax, %%esp\n" | ||
121 | " movl 4(%%esp), %%esi\n" /* esi = in */ | ||
122 | " movl 12(%%esp), %%edi\n" /* edi = out */ | ||
123 | " movl 36(%%esp), %%edx\n" /* edx = hold */ | ||
124 | " movl 40(%%esp), %%ebx\n" /* ebx = bits */ | ||
125 | " movl 44(%%esp), %%ebp\n" /* ebp = lcode */ | ||
126 | |||
127 | " cld\n" | ||
128 | " jmp .L_do_loop\n" | ||
129 | |||
130 | ".L_while_test:\n" | ||
131 | " cmpl %%edi, 20(%%esp)\n" | ||
132 | " jbe .L_break_loop\n" | ||
133 | " cmpl %%esi, 8(%%esp)\n" | ||
134 | " jbe .L_break_loop\n" | ||
135 | |||
136 | ".L_do_loop:\n" | ||
137 | " cmpb $15, %%bl\n" | ||
138 | " ja .L_get_length_code\n" /* if (15 < bits) */ | ||
139 | |||
140 | " xorl %%eax, %%eax\n" | ||
141 | " lodsw\n" /* al = *(ushort *)in++ */ | ||
142 | " movb %%bl, %%cl\n" /* cl = bits, needs it for shifting */ | ||
143 | " addb $16, %%bl\n" /* bits += 16 */ | ||
144 | " shll %%cl, %%eax\n" | ||
145 | " orl %%eax, %%edx\n" /* hold |= *((ushort *)in)++ << bits */ | ||
146 | |||
147 | ".L_get_length_code:\n" | ||
148 | " movl 52(%%esp), %%eax\n" /* eax = lmask */ | ||
149 | " andl %%edx, %%eax\n" /* eax &= hold */ | ||
150 | " movl (%%ebp,%%eax,4), %%eax\n" /* eax = lcode[hold & lmask] */ | ||
151 | |||
152 | ".L_dolen:\n" | ||
153 | " movb %%ah, %%cl\n" /* cl = this.bits */ | ||
154 | " subb %%ah, %%bl\n" /* bits -= this.bits */ | ||
155 | " shrl %%cl, %%edx\n" /* hold >>= this.bits */ | ||
156 | |||
157 | " testb %%al, %%al\n" | ||
158 | " jnz .L_test_for_length_base\n" /* if (op != 0) 45.7% */ | ||
159 | |||
160 | " shrl $16, %%eax\n" /* output this.val char */ | ||
161 | " stosb\n" | ||
162 | " jmp .L_while_test\n" | ||
163 | |||
164 | ".L_test_for_length_base:\n" | ||
165 | " movl %%eax, %%ecx\n" /* len = this */ | ||
166 | " shrl $16, %%ecx\n" /* len = this.val */ | ||
167 | " movl %%ecx, 60(%%esp)\n" /* len = this */ | ||
168 | " movb %%al, %%cl\n" | ||
169 | |||
170 | " testb $16, %%al\n" | ||
171 | " jz .L_test_for_second_level_length\n" /* if ((op & 16) == 0) 8% */ | ||
172 | " andb $15, %%cl\n" /* op &= 15 */ | ||
173 | " jz .L_decode_distance\n" /* if (!op) */ | ||
174 | " cmpb %%cl, %%bl\n" | ||
175 | " jae .L_add_bits_to_len\n" /* if (op <= bits) */ | ||
176 | |||
177 | " movb %%cl, %%ch\n" /* stash op in ch, freeing cl */ | ||
178 | " xorl %%eax, %%eax\n" | ||
179 | " lodsw\n" /* al = *(ushort *)in++ */ | ||
180 | " movb %%bl, %%cl\n" /* cl = bits, needs it for shifting */ | ||
181 | " addb $16, %%bl\n" /* bits += 16 */ | ||
182 | " shll %%cl, %%eax\n" | ||
183 | " orl %%eax, %%edx\n" /* hold |= *((ushort *)in)++ << bits */ | ||
184 | " movb %%ch, %%cl\n" /* move op back to ecx */ | ||
185 | |||
186 | ".L_add_bits_to_len:\n" | ||
187 | " movl $1, %%eax\n" | ||
188 | " shll %%cl, %%eax\n" | ||
189 | " decl %%eax\n" | ||
190 | " subb %%cl, %%bl\n" | ||
191 | " andl %%edx, %%eax\n" /* eax &= hold */ | ||
192 | " shrl %%cl, %%edx\n" | ||
193 | " addl %%eax, 60(%%esp)\n" /* len += hold & mask[op] */ | ||
194 | |||
195 | ".L_decode_distance:\n" | ||
196 | " cmpb $15, %%bl\n" | ||
197 | " ja .L_get_distance_code\n" /* if (15 < bits) */ | ||
198 | |||
199 | " xorl %%eax, %%eax\n" | ||
200 | " lodsw\n" /* al = *(ushort *)in++ */ | ||
201 | " movb %%bl, %%cl\n" /* cl = bits, needs it for shifting */ | ||
202 | " addb $16, %%bl\n" /* bits += 16 */ | ||
203 | " shll %%cl, %%eax\n" | ||
204 | " orl %%eax, %%edx\n" /* hold |= *((ushort *)in)++ << bits */ | ||
205 | |||
206 | ".L_get_distance_code:\n" | ||
207 | " movl 56(%%esp), %%eax\n" /* eax = dmask */ | ||
208 | " movl 48(%%esp), %%ecx\n" /* ecx = dcode */ | ||
209 | " andl %%edx, %%eax\n" /* eax &= hold */ | ||
210 | " movl (%%ecx,%%eax,4), %%eax\n"/* eax = dcode[hold & dmask] */ | ||
211 | |||
212 | ".L_dodist:\n" | ||
213 | " movl %%eax, %%ebp\n" /* dist = this */ | ||
214 | " shrl $16, %%ebp\n" /* dist = this.val */ | ||
215 | " movb %%ah, %%cl\n" | ||
216 | " subb %%ah, %%bl\n" /* bits -= this.bits */ | ||
217 | " shrl %%cl, %%edx\n" /* hold >>= this.bits */ | ||
218 | " movb %%al, %%cl\n" /* cl = this.op */ | ||
219 | |||
220 | " testb $16, %%al\n" /* if ((op & 16) == 0) */ | ||
221 | " jz .L_test_for_second_level_dist\n" | ||
222 | " andb $15, %%cl\n" /* op &= 15 */ | ||
223 | " jz .L_check_dist_one\n" | ||
224 | " cmpb %%cl, %%bl\n" | ||
225 | " jae .L_add_bits_to_dist\n" /* if (op <= bits) 97.6% */ | ||
226 | |||
227 | " movb %%cl, %%ch\n" /* stash op in ch, freeing cl */ | ||
228 | " xorl %%eax, %%eax\n" | ||
229 | " lodsw\n" /* al = *(ushort *)in++ */ | ||
230 | " movb %%bl, %%cl\n" /* cl = bits, needs it for shifting */ | ||
231 | " addb $16, %%bl\n" /* bits += 16 */ | ||
232 | " shll %%cl, %%eax\n" | ||
233 | " orl %%eax, %%edx\n" /* hold |= *((ushort *)in)++ << bits */ | ||
234 | " movb %%ch, %%cl\n" /* move op back to ecx */ | ||
235 | |||
236 | ".L_add_bits_to_dist:\n" | ||
237 | " movl $1, %%eax\n" | ||
238 | " shll %%cl, %%eax\n" | ||
239 | " decl %%eax\n" /* (1 << op) - 1 */ | ||
240 | " subb %%cl, %%bl\n" | ||
241 | " andl %%edx, %%eax\n" /* eax &= hold */ | ||
242 | " shrl %%cl, %%edx\n" | ||
243 | " addl %%eax, %%ebp\n" /* dist += hold & ((1 << op) - 1) */ | ||
244 | |||
245 | ".L_check_window:\n" | ||
246 | " movl %%esi, 4(%%esp)\n" /* save in so from can use it's reg */ | ||
247 | " movl %%edi, %%eax\n" | ||
248 | " subl 16(%%esp), %%eax\n" /* nbytes = out - beg */ | ||
249 | |||
250 | " cmpl %%ebp, %%eax\n" | ||
251 | " jb .L_clip_window\n" /* if (dist > nbytes) 4.2% */ | ||
252 | |||
253 | " movl 60(%%esp), %%ecx\n" | ||
254 | " movl %%edi, %%esi\n" | ||
255 | " subl %%ebp, %%esi\n" /* from = out - dist */ | ||
256 | |||
257 | " subl $3, %%ecx\n" /* copy from to out */ | ||
258 | " movb (%%esi), %%al\n" | ||
259 | " movb %%al, (%%edi)\n" | ||
260 | " movb 1(%%esi), %%al\n" | ||
261 | " movb 2(%%esi), %%ah\n" | ||
262 | " addl $3, %%esi\n" | ||
263 | " movb %%al, 1(%%edi)\n" | ||
264 | " movb %%ah, 2(%%edi)\n" | ||
265 | " addl $3, %%edi\n" | ||
266 | " rep movsb\n" | ||
267 | |||
268 | " movl 4(%%esp), %%esi\n" /* move in back to %esi, toss from */ | ||
269 | " movl 44(%%esp), %%ebp\n" /* ebp = lcode */ | ||
270 | " jmp .L_while_test\n" | ||
271 | |||
272 | ".L_check_dist_one:\n" | ||
273 | " cmpl $1, %%ebp\n" /* if dist 1, is a memset */ | ||
274 | " jne .L_check_window\n" | ||
275 | " cmpl %%edi, 16(%%esp)\n" | ||
276 | " je .L_check_window\n" | ||
277 | |||
278 | " decl %%edi\n" | ||
279 | " movl 60(%%esp), %%ecx\n" | ||
280 | " movb (%%edi), %%al\n" | ||
281 | " subl $3, %%ecx\n" | ||
282 | |||
283 | " movb %%al, 1(%%edi)\n" /* memset out with from[-1] */ | ||
284 | " movb %%al, 2(%%edi)\n" | ||
285 | " movb %%al, 3(%%edi)\n" | ||
286 | " addl $4, %%edi\n" | ||
287 | " rep stosb\n" | ||
288 | " movl 44(%%esp), %%ebp\n" /* ebp = lcode */ | ||
289 | " jmp .L_while_test\n" | ||
290 | |||
291 | ".L_test_for_second_level_length:\n" | ||
292 | " testb $64, %%al\n" | ||
293 | " jnz .L_test_for_end_of_block\n" /* if ((op & 64) != 0) */ | ||
294 | |||
295 | " movl $1, %%eax\n" | ||
296 | " shll %%cl, %%eax\n" | ||
297 | " decl %%eax\n" | ||
298 | " andl %%edx, %%eax\n" /* eax &= hold */ | ||
299 | " addl 60(%%esp), %%eax\n" /* eax += this.val */ | ||
300 | " movl (%%ebp,%%eax,4), %%eax\n" /* eax = lcode[val+(hold&mask[op])]*/ | ||
301 | " jmp .L_dolen\n" | ||
302 | |||
303 | ".L_test_for_second_level_dist:\n" | ||
304 | " testb $64, %%al\n" | ||
305 | " jnz .L_invalid_distance_code\n" /* if ((op & 64) != 0) */ | ||
306 | |||
307 | " movl $1, %%eax\n" | ||
308 | " shll %%cl, %%eax\n" | ||
309 | " decl %%eax\n" | ||
310 | " andl %%edx, %%eax\n" /* eax &= hold */ | ||
311 | " addl %%ebp, %%eax\n" /* eax += this.val */ | ||
312 | " movl 48(%%esp), %%ecx\n" /* ecx = dcode */ | ||
313 | " movl (%%ecx,%%eax,4), %%eax\n" /* eax = dcode[val+(hold&mask[op])]*/ | ||
314 | " jmp .L_dodist\n" | ||
315 | |||
316 | ".L_clip_window:\n" | ||
317 | " movl %%eax, %%ecx\n" | ||
318 | " movl 24(%%esp), %%eax\n" /* prepare for dist compare */ | ||
319 | " negl %%ecx\n" /* nbytes = -nbytes */ | ||
320 | " movl 32(%%esp), %%esi\n" /* from = window */ | ||
321 | |||
322 | " cmpl %%ebp, %%eax\n" | ||
323 | " jb .L_invalid_distance_too_far\n" /* if (dist > wsize) */ | ||
324 | |||
325 | " addl %%ebp, %%ecx\n" /* nbytes = dist - nbytes */ | ||
326 | " cmpl $0, 28(%%esp)\n" | ||
327 | " jne .L_wrap_around_window\n" /* if (write != 0) */ | ||
328 | |||
329 | " subl %%ecx, %%eax\n" | ||
330 | " addl %%eax, %%esi\n" /* from += wsize - nbytes */ | ||
331 | |||
332 | " movl 60(%%esp), %%eax\n" | ||
333 | " cmpl %%ecx, %%eax\n" | ||
334 | " jbe .L_do_copy1\n" /* if (nbytes >= len) */ | ||
335 | |||
336 | " subl %%ecx, %%eax\n" /* len -= nbytes */ | ||
337 | " rep movsb\n" | ||
338 | " movl %%edi, %%esi\n" | ||
339 | " subl %%ebp, %%esi\n" /* from = out - dist */ | ||
340 | " jmp .L_do_copy1\n" | ||
341 | |||
342 | " cmpl %%ecx, %%eax\n" | ||
343 | " jbe .L_do_copy1\n" /* if (nbytes >= len) */ | ||
344 | |||
345 | " subl %%ecx, %%eax\n" /* len -= nbytes */ | ||
346 | " rep movsb\n" | ||
347 | " movl %%edi, %%esi\n" | ||
348 | " subl %%ebp, %%esi\n" /* from = out - dist */ | ||
349 | " jmp .L_do_copy1\n" | ||
350 | |||
351 | ".L_wrap_around_window:\n" | ||
352 | " movl 28(%%esp), %%eax\n" | ||
353 | " cmpl %%eax, %%ecx\n" | ||
354 | " jbe .L_contiguous_in_window\n" /* if (write >= nbytes) */ | ||
355 | |||
356 | " addl 24(%%esp), %%esi\n" | ||
357 | " addl %%eax, %%esi\n" | ||
358 | " subl %%ecx, %%esi\n" /* from += wsize + write - nbytes */ | ||
359 | " subl %%eax, %%ecx\n" /* nbytes -= write */ | ||
360 | |||
361 | " movl 60(%%esp), %%eax\n" | ||
362 | " cmpl %%ecx, %%eax\n" | ||
363 | " jbe .L_do_copy1\n" /* if (nbytes >= len) */ | ||
364 | |||
365 | " subl %%ecx, %%eax\n" /* len -= nbytes */ | ||
366 | " rep movsb\n" | ||
367 | " movl 32(%%esp), %%esi\n" /* from = window */ | ||
368 | " movl 28(%%esp), %%ecx\n" /* nbytes = write */ | ||
369 | " cmpl %%ecx, %%eax\n" | ||
370 | " jbe .L_do_copy1\n" /* if (nbytes >= len) */ | ||
371 | |||
372 | " subl %%ecx, %%eax\n" /* len -= nbytes */ | ||
373 | " rep movsb\n" | ||
374 | " movl %%edi, %%esi\n" | ||
375 | " subl %%ebp, %%esi\n" /* from = out - dist */ | ||
376 | " jmp .L_do_copy1\n" | ||
377 | |||
378 | ".L_contiguous_in_window:\n" | ||
379 | " addl %%eax, %%esi\n" | ||
380 | " subl %%ecx, %%esi\n" /* from += write - nbytes */ | ||
381 | |||
382 | " movl 60(%%esp), %%eax\n" | ||
383 | " cmpl %%ecx, %%eax\n" | ||
384 | " jbe .L_do_copy1\n" /* if (nbytes >= len) */ | ||
385 | |||
386 | " subl %%ecx, %%eax\n" /* len -= nbytes */ | ||
387 | " rep movsb\n" | ||
388 | " movl %%edi, %%esi\n" | ||
389 | " subl %%ebp, %%esi\n" /* from = out - dist */ | ||
390 | |||
391 | ".L_do_copy1:\n" | ||
392 | " movl %%eax, %%ecx\n" | ||
393 | " rep movsb\n" | ||
394 | |||
395 | " movl 4(%%esp), %%esi\n" /* move in back to %esi, toss from */ | ||
396 | " movl 44(%%esp), %%ebp\n" /* ebp = lcode */ | ||
397 | " jmp .L_while_test\n" | ||
398 | |||
399 | ".L_test_for_end_of_block:\n" | ||
400 | " testb $32, %%al\n" | ||
401 | " jz .L_invalid_literal_length_code\n" | ||
402 | " movl $1, 68(%%esp)\n" | ||
403 | " jmp .L_break_loop_with_status\n" | ||
404 | |||
405 | ".L_invalid_literal_length_code:\n" | ||
406 | " movl $2, 68(%%esp)\n" | ||
407 | " jmp .L_break_loop_with_status\n" | ||
408 | |||
409 | ".L_invalid_distance_code:\n" | ||
410 | " movl $3, 68(%%esp)\n" | ||
411 | " jmp .L_break_loop_with_status\n" | ||
412 | |||
413 | ".L_invalid_distance_too_far:\n" | ||
414 | " movl 4(%%esp), %%esi\n" | ||
415 | " movl $4, 68(%%esp)\n" | ||
416 | " jmp .L_break_loop_with_status\n" | ||
417 | |||
418 | ".L_break_loop:\n" | ||
419 | " movl $0, 68(%%esp)\n" | ||
420 | |||
421 | ".L_break_loop_with_status:\n" | ||
422 | /* put in, out, bits, and hold back into ar and pop esp */ | ||
423 | " movl %%esi, 4(%%esp)\n" | ||
424 | " movl %%edi, 12(%%esp)\n" | ||
425 | " movl %%ebx, 40(%%esp)\n" | ||
426 | " movl %%edx, 36(%%esp)\n" | ||
427 | " movl (%%esp), %%esp\n" | ||
428 | " popl %%ebp\n" | ||
429 | " popf\n" | ||
430 | : | ||
431 | : "m" (ar) | ||
432 | : "memory", "%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi" | ||
433 | ); | ||
434 | #elif defined( _MSC_VER ) | ||
435 | __asm { | ||
436 | lea eax, ar | ||
437 | pushfd | ||
438 | push ebp | ||
439 | mov [eax], esp | ||
440 | mov esp, eax | ||
441 | mov esi, [esp+4] /* esi = in */ | ||
442 | mov edi, [esp+12] /* edi = out */ | ||
443 | mov edx, [esp+36] /* edx = hold */ | ||
444 | mov ebx, [esp+40] /* ebx = bits */ | ||
445 | mov ebp, [esp+44] /* ebp = lcode */ | ||
446 | |||
447 | cld | ||
448 | jmp L_do_loop | ||
449 | |||
450 | L_while_test: | ||
451 | cmp [esp+20], edi | ||
452 | jbe L_break_loop | ||
453 | cmp [esp+8], esi | ||
454 | jbe L_break_loop | ||
455 | |||
456 | L_do_loop: | ||
457 | cmp bl, 15 | ||
458 | ja L_get_length_code /* if (15 < bits) */ | ||
459 | |||
460 | xor eax, eax | ||
461 | lodsw /* al = *(ushort *)in++ */ | ||
462 | mov cl, bl /* cl = bits, needs it for shifting */ | ||
463 | add bl, 16 /* bits += 16 */ | ||
464 | shl eax, cl | ||
465 | or edx, eax /* hold |= *((ushort *)in)++ << bits */ | ||
466 | |||
467 | L_get_length_code: | ||
468 | mov eax, [esp+52] /* eax = lmask */ | ||
469 | and eax, edx /* eax &= hold */ | ||
470 | mov eax, [ebp+eax*4] /* eax = lcode[hold & lmask] */ | ||
471 | |||
472 | L_dolen: | ||
473 | mov cl, ah /* cl = this.bits */ | ||
474 | sub bl, ah /* bits -= this.bits */ | ||
475 | shr edx, cl /* hold >>= this.bits */ | ||
476 | |||
477 | test al, al | ||
478 | jnz L_test_for_length_base /* if (op != 0) 45.7% */ | ||
479 | |||
480 | shr eax, 16 /* output this.val char */ | ||
481 | stosb | ||
482 | jmp L_while_test | ||
483 | |||
484 | L_test_for_length_base: | ||
485 | mov ecx, eax /* len = this */ | ||
486 | shr ecx, 16 /* len = this.val */ | ||
487 | mov [esp+60], ecx /* len = this */ | ||
488 | mov cl, al | ||
489 | |||
490 | test al, 16 | ||
491 | jz L_test_for_second_level_length /* if ((op & 16) == 0) 8% */ | ||
492 | and cl, 15 /* op &= 15 */ | ||
493 | jz L_decode_distance /* if (!op) */ | ||
494 | cmp bl, cl | ||
495 | jae L_add_bits_to_len /* if (op <= bits) */ | ||
496 | |||
497 | mov ch, cl /* stash op in ch, freeing cl */ | ||
498 | xor eax, eax | ||
499 | lodsw /* al = *(ushort *)in++ */ | ||
500 | mov cl, bl /* cl = bits, needs it for shifting */ | ||
501 | add bl, 16 /* bits += 16 */ | ||
502 | shl eax, cl | ||
503 | or edx, eax /* hold |= *((ushort *)in)++ << bits */ | ||
504 | mov cl, ch /* move op back to ecx */ | ||
505 | |||
506 | L_add_bits_to_len: | ||
507 | mov eax, 1 | ||
508 | shl eax, cl | ||
509 | dec eax | ||
510 | sub bl, cl | ||
511 | and eax, edx /* eax &= hold */ | ||
512 | shr edx, cl | ||
513 | add [esp+60], eax /* len += hold & mask[op] */ | ||
514 | |||
515 | L_decode_distance: | ||
516 | cmp bl, 15 | ||
517 | ja L_get_distance_code /* if (15 < bits) */ | ||
518 | |||
519 | xor eax, eax | ||
520 | lodsw /* al = *(ushort *)in++ */ | ||
521 | mov cl, bl /* cl = bits, needs it for shifting */ | ||
522 | add bl, 16 /* bits += 16 */ | ||
523 | shl eax, cl | ||
524 | or edx, eax /* hold |= *((ushort *)in)++ << bits */ | ||
525 | |||
526 | L_get_distance_code: | ||
527 | mov eax, [esp+56] /* eax = dmask */ | ||
528 | mov ecx, [esp+48] /* ecx = dcode */ | ||
529 | and eax, edx /* eax &= hold */ | ||
530 | mov eax, [ecx+eax*4]/* eax = dcode[hold & dmask] */ | ||
531 | |||
532 | L_dodist: | ||
533 | mov ebp, eax /* dist = this */ | ||
534 | shr ebp, 16 /* dist = this.val */ | ||
535 | mov cl, ah | ||
536 | sub bl, ah /* bits -= this.bits */ | ||
537 | shr edx, cl /* hold >>= this.bits */ | ||
538 | mov cl, al /* cl = this.op */ | ||
539 | |||
540 | test al, 16 /* if ((op & 16) == 0) */ | ||
541 | jz L_test_for_second_level_dist | ||
542 | and cl, 15 /* op &= 15 */ | ||
543 | jz L_check_dist_one | ||
544 | cmp bl, cl | ||
545 | jae L_add_bits_to_dist /* if (op <= bits) 97.6% */ | ||
546 | |||
547 | mov ch, cl /* stash op in ch, freeing cl */ | ||
548 | xor eax, eax | ||
549 | lodsw /* al = *(ushort *)in++ */ | ||
550 | mov cl, bl /* cl = bits, needs it for shifting */ | ||
551 | add bl, 16 /* bits += 16 */ | ||
552 | shl eax, cl | ||
553 | or edx, eax /* hold |= *((ushort *)in)++ << bits */ | ||
554 | mov cl, ch /* move op back to ecx */ | ||
555 | |||
556 | L_add_bits_to_dist: | ||
557 | mov eax, 1 | ||
558 | shl eax, cl | ||
559 | dec eax /* (1 << op) - 1 */ | ||
560 | sub bl, cl | ||
561 | and eax, edx /* eax &= hold */ | ||
562 | shr edx, cl | ||
563 | add ebp, eax /* dist += hold & ((1 << op) - 1) */ | ||
564 | |||
565 | L_check_window: | ||
566 | mov [esp+4], esi /* save in so from can use it's reg */ | ||
567 | mov eax, edi | ||
568 | sub eax, [esp+16] /* nbytes = out - beg */ | ||
569 | |||
570 | cmp eax, ebp | ||
571 | jb L_clip_window /* if (dist > nbytes) 4.2% */ | ||
572 | |||
573 | mov ecx, [esp+60] | ||
574 | mov esi, edi | ||
575 | sub esi, ebp /* from = out - dist */ | ||
576 | |||
577 | sub ecx, 3 /* copy from to out */ | ||
578 | mov al, [esi] | ||
579 | mov [edi], al | ||
580 | mov al, [esi+1] | ||
581 | mov ah, [esi+2] | ||
582 | add esi, 3 | ||
583 | mov [edi+1], al | ||
584 | mov [edi+2], ah | ||
585 | add edi, 3 | ||
586 | rep movsb | ||
587 | |||
588 | mov esi, [esp+4] /* move in back to %esi, toss from */ | ||
589 | mov ebp, [esp+44] /* ebp = lcode */ | ||
590 | jmp L_while_test | ||
591 | |||
592 | L_check_dist_one: | ||
593 | cmp ebp, 1 /* if dist 1, is a memset */ | ||
594 | jne L_check_window | ||
595 | cmp [esp+16], edi | ||
596 | je L_check_window | ||
597 | |||
598 | dec edi | ||
599 | mov ecx, [esp+60] | ||
600 | mov al, [edi] | ||
601 | sub ecx, 3 | ||
602 | |||
603 | mov [edi+1], al /* memset out with from[-1] */ | ||
604 | mov [edi+2], al | ||
605 | mov [edi+3], al | ||
606 | add edi, 4 | ||
607 | rep stosb | ||
608 | mov ebp, [esp+44] /* ebp = lcode */ | ||
609 | jmp L_while_test | ||
610 | |||
611 | L_test_for_second_level_length: | ||
612 | test al, 64 | ||
613 | jnz L_test_for_end_of_block /* if ((op & 64) != 0) */ | ||
614 | |||
615 | mov eax, 1 | ||
616 | shl eax, cl | ||
617 | dec eax | ||
618 | and eax, edx /* eax &= hold */ | ||
619 | add eax, [esp+60] /* eax += this.val */ | ||
620 | mov eax, [ebp+eax*4] /* eax = lcode[val+(hold&mask[op])]*/ | ||
621 | jmp L_dolen | ||
622 | |||
623 | L_test_for_second_level_dist: | ||
624 | test al, 64 | ||
625 | jnz L_invalid_distance_code /* if ((op & 64) != 0) */ | ||
626 | |||
627 | mov eax, 1 | ||
628 | shl eax, cl | ||
629 | dec eax | ||
630 | and eax, edx /* eax &= hold */ | ||
631 | add eax, ebp /* eax += this.val */ | ||
632 | mov ecx, [esp+48] /* ecx = dcode */ | ||
633 | mov eax, [ecx+eax*4] /* eax = dcode[val+(hold&mask[op])]*/ | ||
634 | jmp L_dodist | ||
635 | |||
636 | L_clip_window: | ||
637 | mov ecx, eax | ||
638 | mov eax, [esp+24] /* prepare for dist compare */ | ||
639 | neg ecx /* nbytes = -nbytes */ | ||
640 | mov esi, [esp+32] /* from = window */ | ||
641 | |||
642 | cmp eax, ebp | ||
643 | jb L_invalid_distance_too_far /* if (dist > wsize) */ | ||
644 | |||
645 | add ecx, ebp /* nbytes = dist - nbytes */ | ||
646 | cmp dword ptr [esp+28], 0 | ||
647 | jne L_wrap_around_window /* if (write != 0) */ | ||
648 | |||
649 | sub eax, ecx | ||
650 | add esi, eax /* from += wsize - nbytes */ | ||
651 | |||
652 | mov eax, [esp+60] | ||
653 | cmp eax, ecx | ||
654 | jbe L_do_copy1 /* if (nbytes >= len) */ | ||
655 | |||
656 | sub eax, ecx /* len -= nbytes */ | ||
657 | rep movsb | ||
658 | mov esi, edi | ||
659 | sub esi, ebp /* from = out - dist */ | ||
660 | jmp L_do_copy1 | ||
661 | |||
662 | cmp eax, ecx | ||
663 | jbe L_do_copy1 /* if (nbytes >= len) */ | ||
664 | |||
665 | sub eax, ecx /* len -= nbytes */ | ||
666 | rep movsb | ||
667 | mov esi, edi | ||
668 | sub esi, ebp /* from = out - dist */ | ||
669 | jmp L_do_copy1 | ||
670 | |||
671 | L_wrap_around_window: | ||
672 | mov eax, [esp+28] | ||
673 | cmp ecx, eax | ||
674 | jbe L_contiguous_in_window /* if (write >= nbytes) */ | ||
675 | |||
676 | add esi, [esp+24] | ||
677 | add esi, eax | ||
678 | sub esi, ecx /* from += wsize + write - nbytes */ | ||
679 | sub ecx, eax /* nbytes -= write */ | ||
680 | |||
681 | mov eax, [esp+60] | ||
682 | cmp eax, ecx | ||
683 | jbe L_do_copy1 /* if (nbytes >= len) */ | ||
684 | |||
685 | sub eax, ecx /* len -= nbytes */ | ||
686 | rep movsb | ||
687 | mov esi, [esp+32] /* from = window */ | ||
688 | mov ecx, [esp+28] /* nbytes = write */ | ||
689 | cmp eax, ecx | ||
690 | jbe L_do_copy1 /* if (nbytes >= len) */ | ||
691 | |||
692 | sub eax, ecx /* len -= nbytes */ | ||
693 | rep movsb | ||
694 | mov esi, edi | ||
695 | sub esi, ebp /* from = out - dist */ | ||
696 | jmp L_do_copy1 | ||
697 | |||
698 | L_contiguous_in_window: | ||
699 | add esi, eax | ||
700 | sub esi, ecx /* from += write - nbytes */ | ||
701 | |||
702 | mov eax, [esp+60] | ||
703 | cmp eax, ecx | ||
704 | jbe L_do_copy1 /* if (nbytes >= len) */ | ||
705 | |||
706 | sub eax, ecx /* len -= nbytes */ | ||
707 | rep movsb | ||
708 | mov esi, edi | ||
709 | sub esi, ebp /* from = out - dist */ | ||
710 | |||
711 | L_do_copy1: | ||
712 | mov ecx, eax | ||
713 | rep movsb | ||
714 | |||
715 | mov esi, [esp+4] /* move in back to %esi, toss from */ | ||
716 | mov ebp, [esp+44] /* ebp = lcode */ | ||
717 | jmp L_while_test | ||
718 | |||
719 | L_test_for_end_of_block: | ||
720 | test al, 32 | ||
721 | jz L_invalid_literal_length_code | ||
722 | mov dword ptr [esp+68], 1 | ||
723 | jmp L_break_loop_with_status | ||
724 | |||
725 | L_invalid_literal_length_code: | ||
726 | mov dword ptr [esp+68], 2 | ||
727 | jmp L_break_loop_with_status | ||
728 | |||
729 | L_invalid_distance_code: | ||
730 | mov dword ptr [esp+68], 3 | ||
731 | jmp L_break_loop_with_status | ||
732 | |||
733 | L_invalid_distance_too_far: | ||
734 | mov esi, [esp+4] | ||
735 | mov dword ptr [esp+68], 4 | ||
736 | jmp L_break_loop_with_status | ||
737 | |||
738 | L_break_loop: | ||
739 | mov dword ptr [esp+68], 0 | ||
740 | |||
741 | L_break_loop_with_status: | ||
742 | /* put in, out, bits, and hold back into ar and pop esp */ | ||
743 | mov [esp+4], esi | ||
744 | mov [esp+12], edi | ||
745 | mov [esp+40], ebx | ||
746 | mov [esp+36], edx | ||
747 | mov esp, [esp] | ||
748 | pop ebp | ||
749 | popfd | ||
750 | } | ||
751 | #endif | ||
752 | |||
753 | if (ar.status > 1) { | ||
754 | if (ar.status == 2) | ||
755 | strm->msg = "invalid literal/length code"; | ||
756 | else if (ar.status == 3) | ||
757 | strm->msg = "invalid distance code"; | ||
758 | else | ||
759 | strm->msg = "invalid distance too far back"; | ||
760 | state->mode = BAD; | ||
761 | } | ||
762 | else if ( ar.status == 1 ) { | ||
763 | state->mode = TYPE; | ||
764 | } | ||
765 | |||
766 | /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ | ||
767 | ar.len = ar.bits >> 3; | ||
768 | ar.in -= ar.len; | ||
769 | ar.bits -= ar.len << 3; | ||
770 | ar.hold &= (1U << ar.bits) - 1; | ||
771 | |||
772 | /* update state and return */ | ||
773 | strm->next_in = ar.in; | ||
774 | strm->next_out = ar.out; | ||
775 | strm->avail_in = (unsigned)(ar.in < ar.last ? 5 + (ar.last - ar.in) : | ||
776 | 5 - (ar.in - ar.last)); | ||
777 | strm->avail_out = (unsigned)(ar.out < ar.end ? 257 + (ar.end - ar.out) : | ||
778 | 257 - (ar.out - ar.end)); | ||
779 | state->hold = ar.hold; | ||
780 | state->bits = ar.bits; | ||
781 | return; | ||
782 | } | ||
783 | |||