?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
revert between 56095 -> 55830 in arch
[AROS.git] / workbench / libs / z / contrib / inflate86 / inffas86.c
blob7292f67b753795a33aff274e4adcbf561f78c75c
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 * Dec-29-2003 -- I added AMD64 inflate asm support. This version is also
11 * slightly quicker on x86 systems because, instead of using rep movsb to copy
12 * data, it uses rep movsw, which moves data in 2-byte chunks instead of single
13 * bytes. I've tested the AMD64 code on a Fedora Core 1 + the x86_64 updates
14 * from http://fedora.linux.duke.edu/fc1_x86_64
15 * which is running on an Athlon 64 3000+ / Gigabyte GA-K8VT800M system with
16 * 1GB ram. The 64-bit version is about 4% faster than the 32-bit version,
17 * when decompressing mozilla-source-1.3.tar.gz.
18 *
19 * Mar-13-2003 -- Most of this is derived from inffast.S which is derived from
20 * the gcc -S output of zlib-1.2.0/inffast.c. Zlib-1.2.0 is in beta release at
21 * the moment. I have successfully compiled and tested this code with gcc2.96,
22 * gcc3.2, icc5.0, msvc6.0. It is very close to the speed of inffast.S
23 * compiled with gcc -DNO_MMX, but inffast.S is still faster on the P3 with MMX
24 * enabled. I will attempt to merge the MMX code into this version. Newer
25 * versions of this and inffast.S can be found at
26 * http://www.eetbeetee.com/zlib/ and http://www.charm.net/~christop/zlib/
27 */
28
29 #include "zutil.h"
30 #include "inftrees.h"
31 #include "inflate.h"
32 #include "inffast.h"
33
34 /* Mark Adler's comments from inffast.c: */
35
36 /*
37 Decode literal, length, and distance codes and write out the resulting
38 literal and match bytes until either not enough input or output is
39 available, an end-of-block is encountered, or a data error is encountered.
40 When large enough input and output buffers are supplied to inflate(), for
41 example, a 16K input buffer and a 64K output buffer, more than 95% of the
42 inflate execution time is spent in this routine.
43
44 Entry assumptions:
45
46 state->mode == LEN
47 strm->avail_in >= 6
48 strm->avail_out >= 258
49 start >= strm->avail_out
50 state->bits < 8
51
52 On return, state->mode is one of:
53
54 LEN -- ran out of enough output space or enough available input
55 TYPE -- reached end of block code, inflate() to interpret next block
56 BAD -- error in block data
57
58 Notes:
59
60 - The maximum input bits used by a length/distance pair is 15 bits for the
61 length code, 5 bits for the length extra, 15 bits for the distance code,
62 and 13 bits for the distance extra. This totals 48 bits, or six bytes.
63 Therefore if strm->avail_in >= 6, then there is enough input to avoid
64 checking for available input while decoding.
65
66 - The maximum bytes that a single length/distance pair can output is 258
67 bytes, which is the maximum length that can be coded. inflate_fast()
68 requires strm->avail_out >= 258 for each loop to avoid checking for
69 output space.
70 */
71 void inflate_fast(strm, start)
72 z_streamp strm;
73 unsigned start; /* inflate()'s starting value for strm->avail_out */
74 {
75 struct inflate_state FAR *state;
76 struct inffast_ar {
77 /* 64 32 x86 x86_64 */
78 /* ar offset register */
79 /* 0 0 */ void *esp; /* esp save */
80 /* 8 4 */ void *ebp; /* ebp save */
81 /* 16 8 */ unsigned char FAR *in; /* esi rsi local strm->next_in */
82 /* 24 12 */ unsigned char FAR *last; /* r9 while in < last */
83 /* 32 16 */ unsigned char FAR *out; /* edi rdi local strm->next_out */
84 /* 40 20 */ unsigned char FAR *beg; /* inflate()'s init next_out */
85 /* 48 24 */ unsigned char FAR *end; /* r10 while out < end */
86 /* 56 28 */ unsigned char FAR *window;/* size of window, wsize!=0 */
87 /* 64 32 */ code const FAR *lcode; /* ebp rbp local strm->lencode */
88 /* 72 36 */ code const FAR *dcode; /* r11 local strm->distcode */
89 /* 80 40 */ unsigned long hold; /* edx rdx local strm->hold */
90 /* 88 44 */ unsigned bits; /* ebx rbx local strm->bits */
91 /* 92 48 */ unsigned wsize; /* window size */
92 /* 96 52 */ unsigned write; /* window write index */
93 /*100 56 */ unsigned lmask; /* r12 mask for lcode */
94 /*104 60 */ unsigned dmask; /* r13 mask for dcode */
95 /*108 64 */ unsigned len; /* r14 match length */
96 /*112 68 */ unsigned dist; /* r15 match distance */
97 /*116 72 */ unsigned status; /* set when state chng*/
98 } ar;
99
100 #if defined( __GNUC__ ) && defined( __amd64__ ) && ! defined( __i386 )
101 #define PAD_AVAIL_IN 6
102 #define PAD_AVAIL_OUT 258
103 #else
104 #define PAD_AVAIL_IN 5
105 #define PAD_AVAIL_OUT 257
106 #endif
107
108 /* copy state to local variables */
109 state = (struct inflate_state FAR *)strm->state;
110 ar.in = strm->next_in;
111 ar.last = ar.in + (strm->avail_in - PAD_AVAIL_IN);
112 ar.out = strm->next_out;
113 ar.beg = ar.out - (start - strm->avail_out);
114 ar.end = ar.out + (strm->avail_out - PAD_AVAIL_OUT);
115 ar.wsize = state->wsize;
116 ar.write = state->wnext;
117 ar.window = state->window;
118 ar.hold = state->hold;
119 ar.bits = state->bits;
120 ar.lcode = state->lencode;
121 ar.dcode = state->distcode;
122 ar.lmask = (1U << state->lenbits) - 1;
123 ar.dmask = (1U << state->distbits) - 1;
124
125 /* decode literals and length/distances until end-of-block or not enough
126 input data or output space */
127
128 /* align in on 1/2 hold size boundary */
129 while (((unsigned long)(void *)ar.in & (sizeof(ar.hold) / 2 - 1)) != 0) {
130 ar.hold += (unsigned long)*ar.in++ << ar.bits;
131 ar.bits += 8;
132 }
133
134 #if defined( __GNUC__ ) && defined( __amd64__ ) && ! defined( __i386 )
135 __asm__ __volatile__ (
136 " leaq %0, %%rax\n"
137 " movq %%rbp, 8(%%rax)\n" /* save regs rbp and rsp */
138 " movq %%rsp, (%%rax)\n"
139 " movq %%rax, %%rsp\n" /* make rsp point to &ar */
140 " movq 16(%%rsp), %%rsi\n" /* rsi = in */
141 " movq 32(%%rsp), %%rdi\n" /* rdi = out */
142 " movq 24(%%rsp), %%r9\n" /* r9 = last */
143 " movq 48(%%rsp), %%r10\n" /* r10 = end */
144 " movq 64(%%rsp), %%rbp\n" /* rbp = lcode */
145 " movq 72(%%rsp), %%r11\n" /* r11 = dcode */
146 " movq 80(%%rsp), %%rdx\n" /* rdx = hold */
147 " movl 88(%%rsp), %%ebx\n" /* ebx = bits */
148 " movl 100(%%rsp), %%r12d\n" /* r12d = lmask */
149 " movl 104(%%rsp), %%r13d\n" /* r13d = dmask */
150 /* r14d = len */
151 /* r15d = dist */
152 " cld\n"
153 " cmpq %%rdi, %%r10\n"
154 " je .L_one_time\n" /* if only one decode left */
155 " cmpq %%rsi, %%r9\n"
156 " je .L_one_time\n"
157 " jmp .L_do_loop\n"
158
159 ".L_one_time:\n"
160 " movq %%r12, %%r8\n" /* r8 = lmask */
161 " cmpb $32, %%bl\n"
162 " ja .L_get_length_code_one_time\n"
163
164 " lodsl\n" /* eax = *(uint *)in++ */
165 " movb %%bl, %%cl\n" /* cl = bits, needs it for shifting */
166 " addb $32, %%bl\n" /* bits += 32 */
167 " shlq %%cl, %%rax\n"
168 " orq %%rax, %%rdx\n" /* hold |= *((uint *)in)++ << bits */
169 " jmp .L_get_length_code_one_time\n"
170
171 ".align 32,0x90\n"
172 ".L_while_test:\n"
173 " cmpq %%rdi, %%r10\n"
174 " jbe .L_break_loop\n"
175 " cmpq %%rsi, %%r9\n"
176 " jbe .L_break_loop\n"
177
178 ".L_do_loop:\n"
179 " movq %%r12, %%r8\n" /* r8 = lmask */
180 " cmpb $32, %%bl\n"
181 " ja .L_get_length_code\n" /* if (32 < bits) */
182
183 " lodsl\n" /* eax = *(uint *)in++ */
184 " movb %%bl, %%cl\n" /* cl = bits, needs it for shifting */
185 " addb $32, %%bl\n" /* bits += 32 */
186 " shlq %%cl, %%rax\n"
187 " orq %%rax, %%rdx\n" /* hold |= *((uint *)in)++ << bits */
188
189 ".L_get_length_code:\n"
190 " andq %%rdx, %%r8\n" /* r8 &= hold */
191 " movl (%%rbp,%%r8,4), %%eax\n" /* eax = lcode[hold & lmask] */
192
193 " movb %%ah, %%cl\n" /* cl = this.bits */
194 " subb %%ah, %%bl\n" /* bits -= this.bits */
195 " shrq %%cl, %%rdx\n" /* hold >>= this.bits */
196
197 " testb %%al, %%al\n"
198 " jnz .L_test_for_length_base\n" /* if (op != 0) 45.7% */
199
200 " movq %%r12, %%r8\n" /* r8 = lmask */
201 " shrl $16, %%eax\n" /* output this.val char */
202 " stosb\n"
203
204 ".L_get_length_code_one_time:\n"
205 " andq %%rdx, %%r8\n" /* r8 &= hold */
206 " movl (%%rbp,%%r8,4), %%eax\n" /* eax = lcode[hold & lmask] */
207
208 ".L_dolen:\n"
209 " movb %%ah, %%cl\n" /* cl = this.bits */
210 " subb %%ah, %%bl\n" /* bits -= this.bits */
211 " shrq %%cl, %%rdx\n" /* hold >>= this.bits */
212
213 " testb %%al, %%al\n"
214 " jnz .L_test_for_length_base\n" /* if (op != 0) 45.7% */
215
216 " shrl $16, %%eax\n" /* output this.val char */
217 " stosb\n"
218 " jmp .L_while_test\n"
219
220 ".align 32,0x90\n"
221 ".L_test_for_length_base:\n"
222 " movl %%eax, %%r14d\n" /* len = this */
223 " shrl $16, %%r14d\n" /* len = this.val */
224 " movb %%al, %%cl\n"
225
226 " testb $16, %%al\n"
227 " jz .L_test_for_second_level_length\n" /* if ((op & 16) == 0) 8% */
228 " andb $15, %%cl\n" /* op &= 15 */
229 " jz .L_decode_distance\n" /* if (!op) */
230
231 ".L_add_bits_to_len:\n"
232 " subb %%cl, %%bl\n"
233 " xorl %%eax, %%eax\n"
234 " incl %%eax\n"
235 " shll %%cl, %%eax\n"
236 " decl %%eax\n"
237 " andl %%edx, %%eax\n" /* eax &= hold */
238 " shrq %%cl, %%rdx\n"
239 " addl %%eax, %%r14d\n" /* len += hold & mask[op] */
240
241 ".L_decode_distance:\n"
242 " movq %%r13, %%r8\n" /* r8 = dmask */
243 " cmpb $32, %%bl\n"
244 " ja .L_get_distance_code\n" /* if (32 < bits) */
245
246 " lodsl\n" /* eax = *(uint *)in++ */
247 " movb %%bl, %%cl\n" /* cl = bits, needs it for shifting */
248 " addb $32, %%bl\n" /* bits += 32 */
249 " shlq %%cl, %%rax\n"
250 " orq %%rax, %%rdx\n" /* hold |= *((uint *)in)++ << bits */
251
252 ".L_get_distance_code:\n"
253 " andq %%rdx, %%r8\n" /* r8 &= hold */
254 " movl (%%r11,%%r8,4), %%eax\n" /* eax = dcode[hold & dmask] */
255
256 ".L_dodist:\n"
257 " movl %%eax, %%r15d\n" /* dist = this */
258 " shrl $16, %%r15d\n" /* dist = this.val */
259 " movb %%ah, %%cl\n"
260 " subb %%ah, %%bl\n" /* bits -= this.bits */
261 " shrq %%cl, %%rdx\n" /* hold >>= this.bits */
262 " movb %%al, %%cl\n" /* cl = this.op */
263
264 " testb $16, %%al\n" /* if ((op & 16) == 0) */
265 " jz .L_test_for_second_level_dist\n"
266 " andb $15, %%cl\n" /* op &= 15 */
267 " jz .L_check_dist_one\n"
268
269 ".L_add_bits_to_dist:\n"
270 " subb %%cl, %%bl\n"
271 " xorl %%eax, %%eax\n"
272 " incl %%eax\n"
273 " shll %%cl, %%eax\n"
274 " decl %%eax\n" /* (1 << op) - 1 */
275 " andl %%edx, %%eax\n" /* eax &= hold */
276 " shrq %%cl, %%rdx\n"
277 " addl %%eax, %%r15d\n" /* dist += hold & ((1 << op) - 1) */
278
279 ".L_check_window:\n"
280 " movq %%rsi, %%r8\n" /* save in so from can use it's reg */
281 " movq %%rdi, %%rax\n"
282 " subq 40(%%rsp), %%rax\n" /* nbytes = out - beg */
283
284 " cmpl %%r15d, %%eax\n"
285 " jb .L_clip_window\n" /* if (dist > nbytes) 4.2% */
286
287 " movl %%r14d, %%ecx\n" /* ecx = len */
288 " movq %%rdi, %%rsi\n"
289 " subq %%r15, %%rsi\n" /* from = out - dist */
290
291 " sarl %%ecx\n"
292 " jnc .L_copy_two\n" /* if len % 2 == 0 */
293
294 " rep movsw\n"
295 " movb (%%rsi), %%al\n"
296 " movb %%al, (%%rdi)\n"
297 " incq %%rdi\n"
298
299 " movq %%r8, %%rsi\n" /* move in back to %rsi, toss from */
300 " jmp .L_while_test\n"
301
302 ".L_copy_two:\n"
303 " rep movsw\n"
304 " movq %%r8, %%rsi\n" /* move in back to %rsi, toss from */
305 " jmp .L_while_test\n"
306
307 ".align 32,0x90\n"
308 ".L_check_dist_one:\n"
309 " cmpl $1, %%r15d\n" /* if dist 1, is a memset */
310 " jne .L_check_window\n"
311 " cmpq %%rdi, 40(%%rsp)\n" /* if out == beg, outside window */
312 " je .L_check_window\n"
313
314 " movl %%r14d, %%ecx\n" /* ecx = len */
315 " movb -1(%%rdi), %%al\n"
316 " movb %%al, %%ah\n"
317
318 " sarl %%ecx\n"
319 " jnc .L_set_two\n"
320 " movb %%al, (%%rdi)\n"
321 " incq %%rdi\n"
322
323 ".L_set_two:\n"
324 " rep stosw\n"
325 " jmp .L_while_test\n"
326
327 ".align 32,0x90\n"
328 ".L_test_for_second_level_length:\n"
329 " testb $64, %%al\n"
330 " jnz .L_test_for_end_of_block\n" /* if ((op & 64) != 0) */
331
332 " xorl %%eax, %%eax\n"
333 " incl %%eax\n"
334 " shll %%cl, %%eax\n"
335 " decl %%eax\n"
336 " andl %%edx, %%eax\n" /* eax &= hold */
337 " addl %%r14d, %%eax\n" /* eax += len */
338 " movl (%%rbp,%%rax,4), %%eax\n" /* eax = lcode[val+(hold&mask[op])]*/
339 " jmp .L_dolen\n"
340
341 ".align 32,0x90\n"
342 ".L_test_for_second_level_dist:\n"
343 " testb $64, %%al\n"
344 " jnz .L_invalid_distance_code\n" /* if ((op & 64) != 0) */
345
346 " xorl %%eax, %%eax\n"
347 " incl %%eax\n"
348 " shll %%cl, %%eax\n"
349 " decl %%eax\n"
350 " andl %%edx, %%eax\n" /* eax &= hold */
351 " addl %%r15d, %%eax\n" /* eax += dist */
352 " movl (%%r11,%%rax,4), %%eax\n" /* eax = dcode[val+(hold&mask[op])]*/
353 " jmp .L_dodist\n"
354
355 ".align 32,0x90\n"
356 ".L_clip_window:\n"
357 " movl %%eax, %%ecx\n" /* ecx = nbytes */
358 " movl 92(%%rsp), %%eax\n" /* eax = wsize, prepare for dist cmp */
359 " negl %%ecx\n" /* nbytes = -nbytes */
360
361 " cmpl %%r15d, %%eax\n"
362 " jb .L_invalid_distance_too_far\n" /* if (dist > wsize) */
363
364 " addl %%r15d, %%ecx\n" /* nbytes = dist - nbytes */
365 " cmpl $0, 96(%%rsp)\n"
366 " jne .L_wrap_around_window\n" /* if (write != 0) */
367
368 " movq 56(%%rsp), %%rsi\n" /* from = window */
369 " subl %%ecx, %%eax\n" /* eax -= nbytes */
370 " addq %%rax, %%rsi\n" /* from += wsize - nbytes */
371
372 " movl %%r14d, %%eax\n" /* eax = len */
373 " cmpl %%ecx, %%r14d\n"
374 " jbe .L_do_copy\n" /* if (nbytes >= len) */
375
376 " subl %%ecx, %%eax\n" /* eax -= nbytes */
377 " rep movsb\n"
378 " movq %%rdi, %%rsi\n"
379 " subq %%r15, %%rsi\n" /* from = &out[ -dist ] */
380 " jmp .L_do_copy\n"
381
382 ".align 32,0x90\n"
383 ".L_wrap_around_window:\n"
384 " movl 96(%%rsp), %%eax\n" /* eax = write */
385 " cmpl %%eax, %%ecx\n"
386 " jbe .L_contiguous_in_window\n" /* if (write >= nbytes) */
387
388 " movl 92(%%rsp), %%esi\n" /* from = wsize */
389 " addq 56(%%rsp), %%rsi\n" /* from += window */
390 " addq %%rax, %%rsi\n" /* from += write */
391 " subq %%rcx, %%rsi\n" /* from -= nbytes */
392 " subl %%eax, %%ecx\n" /* nbytes -= write */
393
394 " movl %%r14d, %%eax\n" /* eax = len */
395 " cmpl %%ecx, %%eax\n"
396 " jbe .L_do_copy\n" /* if (nbytes >= len) */
397
398 " subl %%ecx, %%eax\n" /* len -= nbytes */
399 " rep movsb\n"
400 " movq 56(%%rsp), %%rsi\n" /* from = window */
401 " movl 96(%%rsp), %%ecx\n" /* nbytes = write */
402 " cmpl %%ecx, %%eax\n"
403 " jbe .L_do_copy\n" /* if (nbytes >= len) */
404
405 " subl %%ecx, %%eax\n" /* len -= nbytes */
406 " rep movsb\n"
407 " movq %%rdi, %%rsi\n"
408 " subq %%r15, %%rsi\n" /* from = out - dist */
409 " jmp .L_do_copy\n"
410
411 ".align 32,0x90\n"
412 ".L_contiguous_in_window:\n"
413 " movq 56(%%rsp), %%rsi\n" /* rsi = window */
414 " addq %%rax, %%rsi\n"
415 " subq %%rcx, %%rsi\n" /* from += write - nbytes */
416
417 " movl %%r14d, %%eax\n" /* eax = len */
418 " cmpl %%ecx, %%eax\n"
419 " jbe .L_do_copy\n" /* if (nbytes >= len) */
420
421 " subl %%ecx, %%eax\n" /* len -= nbytes */
422 " rep movsb\n"
423 " movq %%rdi, %%rsi\n"
424 " subq %%r15, %%rsi\n" /* from = out - dist */
425 " jmp .L_do_copy\n" /* if (nbytes >= len) */
426
427 ".align 32,0x90\n"
428 ".L_do_copy:\n"
429 " movl %%eax, %%ecx\n" /* ecx = len */
430 " rep movsb\n"
431
432 " movq %%r8, %%rsi\n" /* move in back to %esi, toss from */
433 " jmp .L_while_test\n"
434
435 ".L_test_for_end_of_block:\n"
436 " testb $32, %%al\n"
437 " jz .L_invalid_literal_length_code\n"
438 " movl $1, 116(%%rsp)\n"
439 " jmp .L_break_loop_with_status\n"
440
441 ".L_invalid_literal_length_code:\n"
442 " movl $2, 116(%%rsp)\n"
443 " jmp .L_break_loop_with_status\n"
444
445 ".L_invalid_distance_code:\n"
446 " movl $3, 116(%%rsp)\n"
447 " jmp .L_break_loop_with_status\n"
448
449 ".L_invalid_distance_too_far:\n"
450 " movl $4, 116(%%rsp)\n"
451 " jmp .L_break_loop_with_status\n"
452
453 ".L_break_loop:\n"
454 " movl $0, 116(%%rsp)\n"
455
456 ".L_break_loop_with_status:\n"
457 /* put in, out, bits, and hold back into ar and pop esp */
458 " movq %%rsi, 16(%%rsp)\n" /* in */
459 " movq %%rdi, 32(%%rsp)\n" /* out */
460 " movl %%ebx, 88(%%rsp)\n" /* bits */
461 " movq %%rdx, 80(%%rsp)\n" /* hold */
462 " movq (%%rsp), %%rax\n" /* restore rbp and rsp */
463 " movq 8(%%rsp), %%rbp\n"
464 " movq %%rax, %%rsp\n"
465 :
466 : "m" (ar)
467 : "memory", "%rax", "%rbx", "%rcx", "%rdx", "%rsi", "%rdi",
468 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
469 );
470 #elif ( defined( __GNUC__ ) || defined( __ICC ) ) && defined( __i386 )
471 __asm__ __volatile__ (
472 " leal %0, %%eax\n"
473 " movl %%esp, (%%eax)\n" /* save esp, ebp */
474 " movl %%ebp, 4(%%eax)\n"
475 " movl %%eax, %%esp\n"
476 " movl 8(%%esp), %%esi\n" /* esi = in */
477 " movl 16(%%esp), %%edi\n" /* edi = out */
478 " movl 40(%%esp), %%edx\n" /* edx = hold */
479 " movl 44(%%esp), %%ebx\n" /* ebx = bits */
480 " movl 32(%%esp), %%ebp\n" /* ebp = lcode */
481
482 " cld\n"
483 " jmp .L_do_loop\n"
484
485 ".align 32,0x90\n"
486 ".L_while_test:\n"
487 " cmpl %%edi, 24(%%esp)\n" /* out < end */
488 " jbe .L_break_loop\n"
489 " cmpl %%esi, 12(%%esp)\n" /* in < last */
490 " jbe .L_break_loop\n"
491
492 ".L_do_loop:\n"
493 " cmpb $15, %%bl\n"
494 " ja .L_get_length_code\n" /* if (15 < bits) */
495
496 " xorl %%eax, %%eax\n"
497 " lodsw\n" /* al = *(ushort *)in++ */
498 " movb %%bl, %%cl\n" /* cl = bits, needs it for shifting */
499 " addb $16, %%bl\n" /* bits += 16 */
500 " shll %%cl, %%eax\n"
501 " orl %%eax, %%edx\n" /* hold |= *((ushort *)in)++ << bits */
502
503 ".L_get_length_code:\n"
504 " movl 56(%%esp), %%eax\n" /* eax = lmask */
505 " andl %%edx, %%eax\n" /* eax &= hold */
506 " movl (%%ebp,%%eax,4), %%eax\n" /* eax = lcode[hold & lmask] */
507
508 ".L_dolen:\n"
509 " movb %%ah, %%cl\n" /* cl = this.bits */
510 " subb %%ah, %%bl\n" /* bits -= this.bits */
511 " shrl %%cl, %%edx\n" /* hold >>= this.bits */
512
513 " testb %%al, %%al\n"
514 " jnz .L_test_for_length_base\n" /* if (op != 0) 45.7% */
515
516 " shrl $16, %%eax\n" /* output this.val char */
517 " stosb\n"
518 " jmp .L_while_test\n"
519
520 ".align 32,0x90\n"
521 ".L_test_for_length_base:\n"
522 " movl %%eax, %%ecx\n" /* len = this */
523 " shrl $16, %%ecx\n" /* len = this.val */
524 " movl %%ecx, 64(%%esp)\n" /* save len */
525 " movb %%al, %%cl\n"
526
527 " testb $16, %%al\n"
528 " jz .L_test_for_second_level_length\n" /* if ((op & 16) == 0) 8% */
529 " andb $15, %%cl\n" /* op &= 15 */
530 " jz .L_decode_distance\n" /* if (!op) */
531 " cmpb %%cl, %%bl\n"
532 " jae .L_add_bits_to_len\n" /* if (op <= bits) */
533
534 " movb %%cl, %%ch\n" /* stash op in ch, freeing cl */
535 " xorl %%eax, %%eax\n"
536 " lodsw\n" /* al = *(ushort *)in++ */
537 " movb %%bl, %%cl\n" /* cl = bits, needs it for shifting */
538 " addb $16, %%bl\n" /* bits += 16 */
539 " shll %%cl, %%eax\n"
540 " orl %%eax, %%edx\n" /* hold |= *((ushort *)in)++ << bits */
541 " movb %%ch, %%cl\n" /* move op back to ecx */
542
543 ".L_add_bits_to_len:\n"
544 " subb %%cl, %%bl\n"
545 " xorl %%eax, %%eax\n"
546 " incl %%eax\n"
547 " shll %%cl, %%eax\n"
548 " decl %%eax\n"
549 " andl %%edx, %%eax\n" /* eax &= hold */
550 " shrl %%cl, %%edx\n"
551 " addl %%eax, 64(%%esp)\n" /* len += hold & mask[op] */
552
553 ".L_decode_distance:\n"
554 " cmpb $15, %%bl\n"
555 " ja .L_get_distance_code\n" /* if (15 < bits) */
556
557 " xorl %%eax, %%eax\n"
558 " lodsw\n" /* al = *(ushort *)in++ */
559 " movb %%bl, %%cl\n" /* cl = bits, needs it for shifting */
560 " addb $16, %%bl\n" /* bits += 16 */
561 " shll %%cl, %%eax\n"
562 " orl %%eax, %%edx\n" /* hold |= *((ushort *)in)++ << bits */
563
564 ".L_get_distance_code:\n"
565 " movl 60(%%esp), %%eax\n" /* eax = dmask */
566 " movl 36(%%esp), %%ecx\n" /* ecx = dcode */
567 " andl %%edx, %%eax\n" /* eax &= hold */
568 " movl (%%ecx,%%eax,4), %%eax\n"/* eax = dcode[hold & dmask] */
569
570 ".L_dodist:\n"
571 " movl %%eax, %%ebp\n" /* dist = this */
572 " shrl $16, %%ebp\n" /* dist = this.val */
573 " movb %%ah, %%cl\n"
574 " subb %%ah, %%bl\n" /* bits -= this.bits */
575 " shrl %%cl, %%edx\n" /* hold >>= this.bits */
576 " movb %%al, %%cl\n" /* cl = this.op */
577
578 " testb $16, %%al\n" /* if ((op & 16) == 0) */
579 " jz .L_test_for_second_level_dist\n"
580 " andb $15, %%cl\n" /* op &= 15 */
581 " jz .L_check_dist_one\n"
582 " cmpb %%cl, %%bl\n"
583 " jae .L_add_bits_to_dist\n" /* if (op <= bits) 97.6% */
584
585 " movb %%cl, %%ch\n" /* stash op in ch, freeing cl */
586 " xorl %%eax, %%eax\n"
587 " lodsw\n" /* al = *(ushort *)in++ */
588 " movb %%bl, %%cl\n" /* cl = bits, needs it for shifting */
589 " addb $16, %%bl\n" /* bits += 16 */
590 " shll %%cl, %%eax\n"
591 " orl %%eax, %%edx\n" /* hold |= *((ushort *)in)++ << bits */
592 " movb %%ch, %%cl\n" /* move op back to ecx */
593
594 ".L_add_bits_to_dist:\n"
595 " subb %%cl, %%bl\n"
596 " xorl %%eax, %%eax\n"
597 " incl %%eax\n"
598 " shll %%cl, %%eax\n"
599 " decl %%eax\n" /* (1 << op) - 1 */
600 " andl %%edx, %%eax\n" /* eax &= hold */
601 " shrl %%cl, %%edx\n"
602 " addl %%eax, %%ebp\n" /* dist += hold & ((1 << op) - 1) */
603
604 ".L_check_window:\n"
605 " movl %%esi, 8(%%esp)\n" /* save in so from can use it's reg */
606 " movl %%edi, %%eax\n"
607 " subl 20(%%esp), %%eax\n" /* nbytes = out - beg */
608
609 " cmpl %%ebp, %%eax\n"
610 " jb .L_clip_window\n" /* if (dist > nbytes) 4.2% */
611
612 " movl 64(%%esp), %%ecx\n" /* ecx = len */
613 " movl %%edi, %%esi\n"
614 " subl %%ebp, %%esi\n" /* from = out - dist */
615
616 " sarl %%ecx\n"
617 " jnc .L_copy_two\n" /* if len % 2 == 0 */
618
619 " rep movsw\n"
620 " movb (%%esi), %%al\n"
621 " movb %%al, (%%edi)\n"
622 " incl %%edi\n"
623
624 " movl 8(%%esp), %%esi\n" /* move in back to %esi, toss from */
625 " movl 32(%%esp), %%ebp\n" /* ebp = lcode */
626 " jmp .L_while_test\n"
627
628 ".L_copy_two:\n"
629 " rep movsw\n"
630 " movl 8(%%esp), %%esi\n" /* move in back to %esi, toss from */
631 " movl 32(%%esp), %%ebp\n" /* ebp = lcode */
632 " jmp .L_while_test\n"
633
634 ".align 32,0x90\n"
635 ".L_check_dist_one:\n"
636 " cmpl $1, %%ebp\n" /* if dist 1, is a memset */
637 " jne .L_check_window\n"
638 " cmpl %%edi, 20(%%esp)\n"
639 " je .L_check_window\n" /* out == beg, if outside window */
640
641 " movl 64(%%esp), %%ecx\n" /* ecx = len */
642 " movb -1(%%edi), %%al\n"
643 " movb %%al, %%ah\n"
644
645 " sarl %%ecx\n"
646 " jnc .L_set_two\n"
647 " movb %%al, (%%edi)\n"
648 " incl %%edi\n"
649
650 ".L_set_two:\n"
651 " rep stosw\n"
652 " movl 32(%%esp), %%ebp\n" /* ebp = lcode */
653 " jmp .L_while_test\n"
654
655 ".align 32,0x90\n"
656 ".L_test_for_second_level_length:\n"
657 " testb $64, %%al\n"
658 " jnz .L_test_for_end_of_block\n" /* if ((op & 64) != 0) */
659
660 " xorl %%eax, %%eax\n"
661 " incl %%eax\n"
662 " shll %%cl, %%eax\n"
663 " decl %%eax\n"
664 " andl %%edx, %%eax\n" /* eax &= hold */
665 " addl 64(%%esp), %%eax\n" /* eax += len */
666 " movl (%%ebp,%%eax,4), %%eax\n" /* eax = lcode[val+(hold&mask[op])]*/
667 " jmp .L_dolen\n"
668
669 ".align 32,0x90\n"
670 ".L_test_for_second_level_dist:\n"
671 " testb $64, %%al\n"
672 " jnz .L_invalid_distance_code\n" /* if ((op & 64) != 0) */
673
674 " xorl %%eax, %%eax\n"
675 " incl %%eax\n"
676 " shll %%cl, %%eax\n"
677 " decl %%eax\n"
678 " andl %%edx, %%eax\n" /* eax &= hold */
679 " addl %%ebp, %%eax\n" /* eax += dist */
680 " movl 36(%%esp), %%ecx\n" /* ecx = dcode */
681 " movl (%%ecx,%%eax,4), %%eax\n" /* eax = dcode[val+(hold&mask[op])]*/
682 " jmp .L_dodist\n"
683
684 ".align 32,0x90\n"
685 ".L_clip_window:\n"
686 " movl %%eax, %%ecx\n"
687 " movl 48(%%esp), %%eax\n" /* eax = wsize */
688 " negl %%ecx\n" /* nbytes = -nbytes */
689 " movl 28(%%esp), %%esi\n" /* from = window */
690
691 " cmpl %%ebp, %%eax\n"
692 " jb .L_invalid_distance_too_far\n" /* if (dist > wsize) */
693
694 " addl %%ebp, %%ecx\n" /* nbytes = dist - nbytes */
695 " cmpl $0, 52(%%esp)\n"
696 " jne .L_wrap_around_window\n" /* if (write != 0) */
697
698 " subl %%ecx, %%eax\n"
699 " addl %%eax, %%esi\n" /* from += wsize - nbytes */
700
701 " movl 64(%%esp), %%eax\n" /* eax = len */
702 " cmpl %%ecx, %%eax\n"
703 " jbe .L_do_copy\n" /* if (nbytes >= len) */
704
705 " subl %%ecx, %%eax\n" /* len -= nbytes */
706 " rep movsb\n"
707 " movl %%edi, %%esi\n"
708 " subl %%ebp, %%esi\n" /* from = out - dist */
709 " jmp .L_do_copy\n"
710
711 ".align 32,0x90\n"
712 ".L_wrap_around_window:\n"
713 " movl 52(%%esp), %%eax\n" /* eax = write */
714 " cmpl %%eax, %%ecx\n"
715 " jbe .L_contiguous_in_window\n" /* if (write >= nbytes) */
716
717 " addl 48(%%esp), %%esi\n" /* from += wsize */
718 " addl %%eax, %%esi\n" /* from += write */
719 " subl %%ecx, %%esi\n" /* from -= nbytes */
720 " subl %%eax, %%ecx\n" /* nbytes -= write */
721
722 " movl 64(%%esp), %%eax\n" /* eax = len */
723 " cmpl %%ecx, %%eax\n"
724 " jbe .L_do_copy\n" /* if (nbytes >= len) */
725
726 " subl %%ecx, %%eax\n" /* len -= nbytes */
727 " rep movsb\n"
728 " movl 28(%%esp), %%esi\n" /* from = window */
729 " movl 52(%%esp), %%ecx\n" /* nbytes = write */
730 " cmpl %%ecx, %%eax\n"
731 " jbe .L_do_copy\n" /* if (nbytes >= len) */
732
733 " subl %%ecx, %%eax\n" /* len -= nbytes */
734 " rep movsb\n"
735 " movl %%edi, %%esi\n"
736 " subl %%ebp, %%esi\n" /* from = out - dist */
737 " jmp .L_do_copy\n"
738
739 ".align 32,0x90\n"
740 ".L_contiguous_in_window:\n"
741 " addl %%eax, %%esi\n"
742 " subl %%ecx, %%esi\n" /* from += write - nbytes */
743
744 " movl 64(%%esp), %%eax\n" /* eax = len */
745 " cmpl %%ecx, %%eax\n"
746 " jbe .L_do_copy\n" /* if (nbytes >= len) */
747
748 " subl %%ecx, %%eax\n" /* len -= nbytes */
749 " rep movsb\n"
750 " movl %%edi, %%esi\n"
751 " subl %%ebp, %%esi\n" /* from = out - dist */
752 " jmp .L_do_copy\n" /* if (nbytes >= len) */
753
754 ".align 32,0x90\n"
755 ".L_do_copy:\n"
756 " movl %%eax, %%ecx\n"
757 " rep movsb\n"
758
759 " movl 8(%%esp), %%esi\n" /* move in back to %esi, toss from */
760 " movl 32(%%esp), %%ebp\n" /* ebp = lcode */
761 " jmp .L_while_test\n"
762
763 ".L_test_for_end_of_block:\n"
764 " testb $32, %%al\n"
765 " jz .L_invalid_literal_length_code\n"
766 " movl $1, 72(%%esp)\n"
767 " jmp .L_break_loop_with_status\n"
768
769 ".L_invalid_literal_length_code:\n"
770 " movl $2, 72(%%esp)\n"
771 " jmp .L_break_loop_with_status\n"
772
773 ".L_invalid_distance_code:\n"
774 " movl $3, 72(%%esp)\n"
775 " jmp .L_break_loop_with_status\n"
776
777 ".L_invalid_distance_too_far:\n"
778 " movl 8(%%esp), %%esi\n"
779 " movl $4, 72(%%esp)\n"
780 " jmp .L_break_loop_with_status\n"
781
782 ".L_break_loop:\n"
783 " movl $0, 72(%%esp)\n"
784
785 ".L_break_loop_with_status:\n"
786 /* put in, out, bits, and hold back into ar and pop esp */
787 " movl %%esi, 8(%%esp)\n" /* save in */
788 " movl %%edi, 16(%%esp)\n" /* save out */
789 " movl %%ebx, 44(%%esp)\n" /* save bits */
790 " movl %%edx, 40(%%esp)\n" /* save hold */
791 " movl 4(%%esp), %%ebp\n" /* restore esp, ebp */
792 " movl (%%esp), %%esp\n"
793 :
794 : "m" (ar)
795 : "memory", "%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi"
796 );
797 #elif defined( _MSC_VER ) && ! defined( _M_AMD64 )
798 __asm {
799 lea eax, ar
800 mov [eax], esp /* save esp, ebp */
801 mov [eax+4], ebp
802 mov esp, eax
803 mov esi, [esp+8] /* esi = in */
804 mov edi, [esp+16] /* edi = out */
805 mov edx, [esp+40] /* edx = hold */
806 mov ebx, [esp+44] /* ebx = bits */
807 mov ebp, [esp+32] /* ebp = lcode */
808
809 cld
810 jmp L_do_loop
811
812 ALIGN 4
813 L_while_test:
814 cmp [esp+24], edi
815 jbe L_break_loop
816 cmp [esp+12], esi
817 jbe L_break_loop
818
819 L_do_loop:
820 cmp bl, 15
821 ja L_get_length_code /* if (15 < bits) */
822
823 xor eax, eax
824 lodsw /* al = *(ushort *)in++ */
825 mov cl, bl /* cl = bits, needs it for shifting */
826 add bl, 16 /* bits += 16 */
827 shl eax, cl
828 or edx, eax /* hold |= *((ushort *)in)++ << bits */
829
830 L_get_length_code:
831 mov eax, [esp+56] /* eax = lmask */
832 and eax, edx /* eax &= hold */
833 mov eax, [ebp+eax*4] /* eax = lcode[hold & lmask] */
834
835 L_dolen:
836 mov cl, ah /* cl = this.bits */
837 sub bl, ah /* bits -= this.bits */
838 shr edx, cl /* hold >>= this.bits */
839
840 test al, al
841 jnz L_test_for_length_base /* if (op != 0) 45.7% */
842
843 shr eax, 16 /* output this.val char */
844 stosb
845 jmp L_while_test
846
847 ALIGN 4
848 L_test_for_length_base:
849 mov ecx, eax /* len = this */
850 shr ecx, 16 /* len = this.val */
851 mov [esp+64], ecx /* save len */
852 mov cl, al
853
854 test al, 16
855 jz L_test_for_second_level_length /* if ((op & 16) == 0) 8% */
856 and cl, 15 /* op &= 15 */
857 jz L_decode_distance /* if (!op) */
858 cmp bl, cl
859 jae L_add_bits_to_len /* if (op <= bits) */
860
861 mov ch, cl /* stash op in ch, freeing cl */
862 xor eax, eax
863 lodsw /* al = *(ushort *)in++ */
864 mov cl, bl /* cl = bits, needs it for shifting */
865 add bl, 16 /* bits += 16 */
866 shl eax, cl
867 or edx, eax /* hold |= *((ushort *)in)++ << bits */
868 mov cl, ch /* move op back to ecx */
869
870 L_add_bits_to_len:
871 sub bl, cl
872 xor eax, eax
873 inc eax
874 shl eax, cl
875 dec eax
876 and eax, edx /* eax &= hold */
877 shr edx, cl
878 add [esp+64], eax /* len += hold & mask[op] */
879
880 L_decode_distance:
881 cmp bl, 15
882 ja L_get_distance_code /* if (15 < bits) */
883
884 xor eax, eax
885 lodsw /* al = *(ushort *)in++ */
886 mov cl, bl /* cl = bits, needs it for shifting */
887 add bl, 16 /* bits += 16 */
888 shl eax, cl
889 or edx, eax /* hold |= *((ushort *)in)++ << bits */
890
891 L_get_distance_code:
892 mov eax, [esp+60] /* eax = dmask */
893 mov ecx, [esp+36] /* ecx = dcode */
894 and eax, edx /* eax &= hold */
895 mov eax, [ecx+eax*4]/* eax = dcode[hold & dmask] */
896
897 L_dodist:
898 mov ebp, eax /* dist = this */
899 shr ebp, 16 /* dist = this.val */
900 mov cl, ah
901 sub bl, ah /* bits -= this.bits */
902 shr edx, cl /* hold >>= this.bits */
903 mov cl, al /* cl = this.op */
904
905 test al, 16 /* if ((op & 16) == 0) */
906 jz L_test_for_second_level_dist
907 and cl, 15 /* op &= 15 */
908 jz L_check_dist_one
909 cmp bl, cl
910 jae L_add_bits_to_dist /* if (op <= bits) 97.6% */
911
912 mov ch, cl /* stash op in ch, freeing cl */
913 xor eax, eax
914 lodsw /* al = *(ushort *)in++ */
915 mov cl, bl /* cl = bits, needs it for shifting */
916 add bl, 16 /* bits += 16 */
917 shl eax, cl
918 or edx, eax /* hold |= *((ushort *)in)++ << bits */
919 mov cl, ch /* move op back to ecx */
920
921 L_add_bits_to_dist:
922 sub bl, cl
923 xor eax, eax
924 inc eax
925 shl eax, cl
926 dec eax /* (1 << op) - 1 */
927 and eax, edx /* eax &= hold */
928 shr edx, cl
929 add ebp, eax /* dist += hold & ((1 << op) - 1) */
930
931 L_check_window:
932 mov [esp+8], esi /* save in so from can use it's reg */
933 mov eax, edi
934 sub eax, [esp+20] /* nbytes = out - beg */
935
936 cmp eax, ebp
937 jb L_clip_window /* if (dist > nbytes) 4.2% */
938
939 mov ecx, [esp+64] /* ecx = len */
940 mov esi, edi
941 sub esi, ebp /* from = out - dist */
942
943 sar ecx, 1
944 jnc L_copy_two
945
946 rep movsw
947 mov al, [esi]
948 mov [edi], al
949 inc edi
950
951 mov esi, [esp+8] /* move in back to %esi, toss from */
952 mov ebp, [esp+32] /* ebp = lcode */
953 jmp L_while_test
954
955 L_copy_two:
956 rep movsw
957 mov esi, [esp+8] /* move in back to %esi, toss from */
958 mov ebp, [esp+32] /* ebp = lcode */
959 jmp L_while_test
960
961 ALIGN 4
962 L_check_dist_one:
963 cmp ebp, 1 /* if dist 1, is a memset */
964 jne L_check_window
965 cmp [esp+20], edi
966 je L_check_window /* out == beg, if outside window */
967
968 mov ecx, [esp+64] /* ecx = len */
969 mov al, [edi-1]
970 mov ah, al
971
972 sar ecx, 1
973 jnc L_set_two
974 mov [edi], al /* memset out with from[-1] */
975 inc edi
976
977 L_set_two:
978 rep stosw
979 mov ebp, [esp+32] /* ebp = lcode */
980 jmp L_while_test
981
982 ALIGN 4
983 L_test_for_second_level_length:
984 test al, 64
985 jnz L_test_for_end_of_block /* if ((op & 64) != 0) */
986
987 xor eax, eax
988 inc eax
989 shl eax, cl
990 dec eax
991 and eax, edx /* eax &= hold */
992 add eax, [esp+64] /* eax += len */
993 mov eax, [ebp+eax*4] /* eax = lcode[val+(hold&mask[op])]*/
994 jmp L_dolen
995
996 ALIGN 4
997 L_test_for_second_level_dist:
998 test al, 64
999 jnz L_invalid_distance_code /* if ((op & 64) != 0) */
1000
1001 xor eax, eax
1002 inc eax
1003 shl eax, cl
1004 dec eax
1005 and eax, edx /* eax &= hold */
1006 add eax, ebp /* eax += dist */
1007 mov ecx, [esp+36] /* ecx = dcode */
1008 mov eax, [ecx+eax*4] /* eax = dcode[val+(hold&mask[op])]*/
1009 jmp L_dodist
1010
1011 ALIGN 4
1012 L_clip_window:
1013 mov ecx, eax
1014 mov eax, [esp+48] /* eax = wsize */
1015 neg ecx /* nbytes = -nbytes */
1016 mov esi, [esp+28] /* from = window */
1017
1018 cmp eax, ebp
1019 jb L_invalid_distance_too_far /* if (dist > wsize) */
1020
1021 add ecx, ebp /* nbytes = dist - nbytes */
1022 cmp dword ptr [esp+52], 0
1023 jne L_wrap_around_window /* if (write != 0) */
1024
1025 sub eax, ecx
1026 add esi, eax /* from += wsize - nbytes */
1027
1028 mov eax, [esp+64] /* eax = len */
1029 cmp eax, ecx
1030 jbe L_do_copy /* if (nbytes >= len) */
1031
1032 sub eax, ecx /* len -= nbytes */
1033 rep movsb
1034 mov esi, edi
1035 sub esi, ebp /* from = out - dist */
1036 jmp L_do_copy
1037
1038 ALIGN 4
1039 L_wrap_around_window:
1040 mov eax, [esp+52] /* eax = write */
1041 cmp ecx, eax
1042 jbe L_contiguous_in_window /* if (write >= nbytes) */
1043
1044 add esi, [esp+48] /* from += wsize */
1045 add esi, eax /* from += write */
1046 sub esi, ecx /* from -= nbytes */
1047 sub ecx, eax /* nbytes -= write */
1048
1049 mov eax, [esp+64] /* eax = len */
1050 cmp eax, ecx
1051 jbe L_do_copy /* if (nbytes >= len) */
1052
1053 sub eax, ecx /* len -= nbytes */
1054 rep movsb
1055 mov esi, [esp+28] /* from = window */
1056 mov ecx, [esp+52] /* nbytes = write */
1057 cmp eax, ecx
1058 jbe L_do_copy /* if (nbytes >= len) */
1059
1060 sub eax, ecx /* len -= nbytes */
1061 rep movsb
1062 mov esi, edi
1063 sub esi, ebp /* from = out - dist */
1064 jmp L_do_copy
1065
1066 ALIGN 4
1067 L_contiguous_in_window:
1068 add esi, eax
1069 sub esi, ecx /* from += write - nbytes */
1070
1071 mov eax, [esp+64] /* eax = len */
1072 cmp eax, ecx
1073 jbe L_do_copy /* if (nbytes >= len) */
1074
1075 sub eax, ecx /* len -= nbytes */
1076 rep movsb
1077 mov esi, edi
1078 sub esi, ebp /* from = out - dist */
1079 jmp L_do_copy
1080
1081 ALIGN 4
1082 L_do_copy:
1083 mov ecx, eax
1084 rep movsb
1085
1086 mov esi, [esp+8] /* move in back to %esi, toss from */
1087 mov ebp, [esp+32] /* ebp = lcode */
1088 jmp L_while_test
1089
1090 L_test_for_end_of_block:
1091 test al, 32
1092 jz L_invalid_literal_length_code
1093 mov dword ptr [esp+72], 1
1094 jmp L_break_loop_with_status
1095
1096 L_invalid_literal_length_code:
1097 mov dword ptr [esp+72], 2
1098 jmp L_break_loop_with_status
1099
1100 L_invalid_distance_code:
1101 mov dword ptr [esp+72], 3
1102 jmp L_break_loop_with_status
1103
1104 L_invalid_distance_too_far:
1105 mov esi, [esp+4]
1106 mov dword ptr [esp+72], 4
1107 jmp L_break_loop_with_status
1108
1109 L_break_loop:
1110 mov dword ptr [esp+72], 0
1111
1112 L_break_loop_with_status:
1113 /* put in, out, bits, and hold back into ar and pop esp */
1114 mov [esp+8], esi /* save in */
1115 mov [esp+16], edi /* save out */
1116 mov [esp+44], ebx /* save bits */
1117 mov [esp+40], edx /* save hold */
1118 mov ebp, [esp+4] /* restore esp, ebp */
1119 mov esp, [esp]
1120 }
1121 #else
1122 #error "x86 architecture not defined"
1123 #endif
1124
1125 if (ar.status > 1) {
1126 if (ar.status == 2)
1127 strm->msg = "invalid literal/length code";
1128 else if (ar.status == 3)
1129 strm->msg = "invalid distance code";
1130 else
1131 strm->msg = "invalid distance too far back";
1132 state->mode = BAD;
1133 }
1134 else if ( ar.status == 1 ) {
1135 state->mode = TYPE;
1136 }
1137
1138 /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
1139 ar.len = ar.bits >> 3;
1140 ar.in -= ar.len;
1141 ar.bits -= ar.len << 3;
1142 ar.hold &= (1U << ar.bits) - 1;
1143
1144 /* update state and return */
1145 strm->next_in = ar.in;
1146 strm->next_out = ar.out;
1147 strm->avail_in = (unsigned)(ar.in < ar.last ?
1148 PAD_AVAIL_IN + (ar.last - ar.in) :
1149 PAD_AVAIL_IN - (ar.in - ar.last));
1150 strm->avail_out = (unsigned)(ar.out < ar.end ?
1151 PAD_AVAIL_OUT + (ar.end - ar.out) :
1152 PAD_AVAIL_OUT - (ar.out - ar.end));
1153 state->hold = ar.hold;
1154 state->bits = ar.bits;
1155 return;
1156 }
1157
Mirror of AROS' svn.