source: s10k/CommonLibs/zlib-1.2.8/contrib/inflate86/inffast.S@ 1145

Last change on this file since 1145 was 1096, checked in by s10k, 7 years ago

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)
File size: 41.8 KB
RevLine 
[1096]1/*
2 * inffast.S is a hand tuned assembler version of:
3 *
4 * inffast.c -- fast decoding
5 * Copyright (C) 1995-2003 Mark Adler
6 * For conditions of distribution and use, see copyright notice in zlib.h
7 *
8 * Copyright (C) 2003 Chris Anderson <christop@charm.net>
9 * Please use the copyright conditions above.
10 *
11 * This version (Jan-23-2003) of inflate_fast was coded and tested under
12 * GNU/Linux on a pentium 3, using the gcc-3.2 compiler distribution. On that
13 * machine, I found that gzip style archives decompressed about 20% faster than
14 * the gcc-3.2 -O3 -fomit-frame-pointer compiled version. Your results will
15 * depend on how large of a buffer is used for z_stream.next_in & next_out
16 * (8K-32K worked best for my 256K cpu cache) and how much overhead there is in
17 * stream processing I/O and crc32/addler32. In my case, this routine used
18 * 70% of the cpu time and crc32 used 20%.
19 *
20 * I am confident that this version will work in the general case, but I have
21 * not tested a wide variety of datasets or a wide variety of platforms.
22 *
23 * Jan-24-2003 -- Added -DUSE_MMX define for slightly faster inflating.
24 * It should be a runtime flag instead of compile time flag...
25 *
26 * Jan-26-2003 -- Added runtime check for MMX support with cpuid instruction.
27 * With -DUSE_MMX, only MMX code is compiled. With -DNO_MMX, only non-MMX code
28 * is compiled. Without either option, runtime detection is enabled. Runtime
29 * detection should work on all modern cpus and the recomended algorithm (flip
30 * ID bit on eflags and then use the cpuid instruction) is used in many
31 * multimedia applications. Tested under win2k with gcc-2.95 and gas-2.12
32 * distributed with cygwin3. Compiling with gcc-2.95 -c inffast.S -o
33 * inffast.obj generates a COFF object which can then be linked with MSVC++
34 * compiled code. Tested under FreeBSD 4.7 with gcc-2.95.
35 *
36 * Jan-28-2003 -- Tested Athlon XP... MMX mode is slower than no MMX (and
37 * slower than compiler generated code). Adjusted cpuid check to use the MMX
38 * code only for Pentiums < P4 until I have more data on the P4. Speed
39 * improvment is only about 15% on the Athlon when compared with code generated
40 * with MSVC++. Not sure yet, but I think the P4 will also be slower using the
41 * MMX mode because many of it's x86 ALU instructions execute in .5 cycles and
42 * have less latency than MMX ops. Added code to buffer the last 11 bytes of
43 * the input stream since the MMX code grabs bits in chunks of 32, which
44 * differs from the inffast.c algorithm. I don't think there would have been
45 * read overruns where a page boundary was crossed (a segfault), but there
46 * could have been overruns when next_in ends on unaligned memory (unintialized
47 * memory read).
48 *
49 * Mar-13-2003 -- P4 MMX is slightly slower than P4 NO_MMX. I created a C
50 * version of the non-MMX code so that it doesn't depend on zstrm and zstate
51 * structure offsets which are hard coded in this file. This was last tested
52 * with zlib-1.2.0 which is currently in beta testing, newer versions of this
53 * and inffas86.c can be found at http://www.eetbeetee.com/zlib/ and
54 * http://www.charm.net/~christop/zlib/
55 */
56
57
58/*
59 * if you have underscore linking problems (_inflate_fast undefined), try
60 * using -DGAS_COFF
61 */
62#if ! defined( GAS_COFF ) && ! defined( GAS_ELF )
63
64#if defined( WIN32 ) || defined( __CYGWIN__ )
65#define GAS_COFF /* windows object format */
66#else
67#define GAS_ELF
68#endif
69
70#endif /* ! GAS_COFF && ! GAS_ELF */
71
72
73#if defined( GAS_COFF )
74
75/* coff externals have underscores */
76#define inflate_fast _inflate_fast
77#define inflate_fast_use_mmx _inflate_fast_use_mmx
78
79#endif /* GAS_COFF */
80
81
82.file "inffast.S"
83
84.globl inflate_fast
85
86.text
87.align 4,0
88.L_invalid_literal_length_code_msg:
89.string "invalid literal/length code"
90
91.align 4,0
92.L_invalid_distance_code_msg:
93.string "invalid distance code"
94
95.align 4,0
96.L_invalid_distance_too_far_msg:
97.string "invalid distance too far back"
98
99#if ! defined( NO_MMX )
100.align 4,0
101.L_mask: /* mask[N] = ( 1 << N ) - 1 */
102.long 0
103.long 1
104.long 3
105.long 7
106.long 15
107.long 31
108.long 63
109.long 127
110.long 255
111.long 511
112.long 1023
113.long 2047
114.long 4095
115.long 8191
116.long 16383
117.long 32767
118.long 65535
119.long 131071
120.long 262143
121.long 524287
122.long 1048575
123.long 2097151
124.long 4194303
125.long 8388607
126.long 16777215
127.long 33554431
128.long 67108863
129.long 134217727
130.long 268435455
131.long 536870911
132.long 1073741823
133.long 2147483647
134.long 4294967295
135#endif /* NO_MMX */
136
137.text
138
139/*
140 * struct z_stream offsets, in zlib.h
141 */
142#define next_in_strm 0 /* strm->next_in */
143#define avail_in_strm 4 /* strm->avail_in */
144#define next_out_strm 12 /* strm->next_out */
145#define avail_out_strm 16 /* strm->avail_out */
146#define msg_strm 24 /* strm->msg */
147#define state_strm 28 /* strm->state */
148
149/*
150 * struct inflate_state offsets, in inflate.h
151 */
152#define mode_state 0 /* state->mode */
153#define wsize_state 32 /* state->wsize */
154#define write_state 40 /* state->write */
155#define window_state 44 /* state->window */
156#define hold_state 48 /* state->hold */
157#define bits_state 52 /* state->bits */
158#define lencode_state 68 /* state->lencode */
159#define distcode_state 72 /* state->distcode */
160#define lenbits_state 76 /* state->lenbits */
161#define distbits_state 80 /* state->distbits */
162
163/*
164 * inflate_fast's activation record
165 */
166#define local_var_size 64 /* how much local space for vars */
167#define strm_sp 88 /* first arg: z_stream * (local_var_size + 24) */
168#define start_sp 92 /* second arg: unsigned int (local_var_size + 28) */
169
170/*
171 * offsets for local vars on stack
172 */
173#define out 60 /* unsigned char* */
174#define window 56 /* unsigned char* */
175#define wsize 52 /* unsigned int */
176#define write 48 /* unsigned int */
177#define in 44 /* unsigned char* */
178#define beg 40 /* unsigned char* */
179#define buf 28 /* char[ 12 ] */
180#define len 24 /* unsigned int */
181#define last 20 /* unsigned char* */
182#define end 16 /* unsigned char* */
183#define dcode 12 /* code* */
184#define lcode 8 /* code* */
185#define dmask 4 /* unsigned int */
186#define lmask 0 /* unsigned int */
187
188/*
189 * typedef enum inflate_mode consts, in inflate.h
190 */
191#define INFLATE_MODE_TYPE 11 /* state->mode flags enum-ed in inflate.h */
192#define INFLATE_MODE_BAD 26
193
194
195#if ! defined( USE_MMX ) && ! defined( NO_MMX )
196
197#define RUN_TIME_MMX
198
199#define CHECK_MMX 1
200#define DO_USE_MMX 2
201#define DONT_USE_MMX 3
202
203.globl inflate_fast_use_mmx
204
205.data
206
207.align 4,0
208inflate_fast_use_mmx: /* integer flag for run time control 1=check,2=mmx,3=no */
209.long CHECK_MMX
210
211#if defined( GAS_ELF )
212/* elf info */
213.type inflate_fast_use_mmx,@object
214.size inflate_fast_use_mmx,4
215#endif
216
217#endif /* RUN_TIME_MMX */
218
219#if defined( GAS_COFF )
220/* coff info: scl 2 = extern, type 32 = function */
221.def inflate_fast; .scl 2; .type 32; .endef
222#endif
223
224.text
225
226.align 32,0x90
227inflate_fast:
228 pushl %edi
229 pushl %esi
230 pushl %ebp
231 pushl %ebx
232 pushf /* save eflags (strm_sp, state_sp assumes this is 32 bits) */
233 subl $local_var_size, %esp
234 cld
235
236#define strm_r %esi
237#define state_r %edi
238
239 movl strm_sp(%esp), strm_r
240 movl state_strm(strm_r), state_r
241
242 /* in = strm->next_in;
243 * out = strm->next_out;
244 * last = in + strm->avail_in - 11;
245 * beg = out - (start - strm->avail_out);
246 * end = out + (strm->avail_out - 257);
247 */
248 movl avail_in_strm(strm_r), %edx
249 movl next_in_strm(strm_r), %eax
250
251 addl %eax, %edx /* avail_in += next_in */
252 subl $11, %edx /* avail_in -= 11 */
253
254 movl %eax, in(%esp)
255 movl %edx, last(%esp)
256
257 movl start_sp(%esp), %ebp
258 movl avail_out_strm(strm_r), %ecx
259 movl next_out_strm(strm_r), %ebx
260
261 subl %ecx, %ebp /* start -= avail_out */
262 negl %ebp /* start = -start */
263 addl %ebx, %ebp /* start += next_out */
264
265 subl $257, %ecx /* avail_out -= 257 */
266 addl %ebx, %ecx /* avail_out += out */
267
268 movl %ebx, out(%esp)
269 movl %ebp, beg(%esp)
270 movl %ecx, end(%esp)
271
272 /* wsize = state->wsize;
273 * write = state->write;
274 * window = state->window;
275 * hold = state->hold;
276 * bits = state->bits;
277 * lcode = state->lencode;
278 * dcode = state->distcode;
279 * lmask = ( 1 << state->lenbits ) - 1;
280 * dmask = ( 1 << state->distbits ) - 1;
281 */
282
283 movl lencode_state(state_r), %eax
284 movl distcode_state(state_r), %ecx
285
286 movl %eax, lcode(%esp)
287 movl %ecx, dcode(%esp)
288
289 movl $1, %eax
290 movl lenbits_state(state_r), %ecx
291 shll %cl, %eax
292 decl %eax
293 movl %eax, lmask(%esp)
294
295 movl $1, %eax
296 movl distbits_state(state_r), %ecx
297 shll %cl, %eax
298 decl %eax
299 movl %eax, dmask(%esp)
300
301 movl wsize_state(state_r), %eax
302 movl write_state(state_r), %ecx
303 movl window_state(state_r), %edx
304
305 movl %eax, wsize(%esp)
306 movl %ecx, write(%esp)
307 movl %edx, window(%esp)
308
309 movl hold_state(state_r), %ebp
310 movl bits_state(state_r), %ebx
311
312#undef strm_r
313#undef state_r
314
315#define in_r %esi
316#define from_r %esi
317#define out_r %edi
318
319 movl in(%esp), in_r
320 movl last(%esp), %ecx
321 cmpl in_r, %ecx
322 ja .L_align_long /* if in < last */
323
324 addl $11, %ecx /* ecx = &in[ avail_in ] */
325 subl in_r, %ecx /* ecx = avail_in */
326 movl $12, %eax
327 subl %ecx, %eax /* eax = 12 - avail_in */
328 leal buf(%esp), %edi
329 rep movsb /* memcpy( buf, in, avail_in ) */
330 movl %eax, %ecx
331 xorl %eax, %eax
332 rep stosb /* memset( &buf[ avail_in ], 0, 12 - avail_in ) */
333 leal buf(%esp), in_r /* in = buf */
334 movl in_r, last(%esp) /* last = in, do just one iteration */
335 jmp .L_is_aligned
336
337 /* align in_r on long boundary */
338.L_align_long:
339 testl $3, in_r
340 jz .L_is_aligned
341 xorl %eax, %eax
342 movb (in_r), %al
343 incl in_r
344 movl %ebx, %ecx
345 addl $8, %ebx
346 shll %cl, %eax
347 orl %eax, %ebp
348 jmp .L_align_long
349
350.L_is_aligned:
351 movl out(%esp), out_r
352
353#if defined( NO_MMX )
354 jmp .L_do_loop
355#endif
356
357#if defined( USE_MMX )
358 jmp .L_init_mmx
359#endif
360
361/*** Runtime MMX check ***/
362
363#if defined( RUN_TIME_MMX )
364.L_check_mmx:
365 cmpl $DO_USE_MMX, inflate_fast_use_mmx
366 je .L_init_mmx
367 ja .L_do_loop /* > 2 */
368
369 pushl %eax
370 pushl %ebx
371 pushl %ecx
372 pushl %edx
373 pushf
374 movl (%esp), %eax /* copy eflags to eax */
375 xorl $0x200000, (%esp) /* try toggling ID bit of eflags (bit 21)
376 * to see if cpu supports cpuid...
377 * ID bit method not supported by NexGen but
378 * bios may load a cpuid instruction and
379 * cpuid may be disabled on Cyrix 5-6x86 */
380 popf
381 pushf
382 popl %edx /* copy new eflags to edx */
383 xorl %eax, %edx /* test if ID bit is flipped */
384 jz .L_dont_use_mmx /* not flipped if zero */
385 xorl %eax, %eax
386 cpuid
387 cmpl $0x756e6547, %ebx /* check for GenuineIntel in ebx,ecx,edx */
388 jne .L_dont_use_mmx
389 cmpl $0x6c65746e, %ecx
390 jne .L_dont_use_mmx
391 cmpl $0x49656e69, %edx
392 jne .L_dont_use_mmx
393 movl $1, %eax
394 cpuid /* get cpu features */
395 shrl $8, %eax
396 andl $15, %eax
397 cmpl $6, %eax /* check for Pentium family, is 0xf for P4 */
398 jne .L_dont_use_mmx
399 testl $0x800000, %edx /* test if MMX feature is set (bit 23) */
400 jnz .L_use_mmx
401 jmp .L_dont_use_mmx
402.L_use_mmx:
403 movl $DO_USE_MMX, inflate_fast_use_mmx
404 jmp .L_check_mmx_pop
405.L_dont_use_mmx:
406 movl $DONT_USE_MMX, inflate_fast_use_mmx
407.L_check_mmx_pop:
408 popl %edx
409 popl %ecx
410 popl %ebx
411 popl %eax
412 jmp .L_check_mmx
413#endif
414
415
416/*** Non-MMX code ***/
417
418#if defined ( NO_MMX ) || defined( RUN_TIME_MMX )
419
420#define hold_r %ebp
421#define bits_r %bl
422#define bitslong_r %ebx
423
424.align 32,0x90
425.L_while_test:
426 /* while (in < last && out < end)
427 */
428 cmpl out_r, end(%esp)
429 jbe .L_break_loop /* if (out >= end) */
430
431 cmpl in_r, last(%esp)
432 jbe .L_break_loop
433
434.L_do_loop:
435 /* regs: %esi = in, %ebp = hold, %bl = bits, %edi = out
436 *
437 * do {
438 * if (bits < 15) {
439 * hold |= *((unsigned short *)in)++ << bits;
440 * bits += 16
441 * }
442 * this = lcode[hold & lmask]
443 */
444 cmpb $15, bits_r
445 ja .L_get_length_code /* if (15 < bits) */
446
447 xorl %eax, %eax
448 lodsw /* al = *(ushort *)in++ */
449 movb bits_r, %cl /* cl = bits, needs it for shifting */
450 addb $16, bits_r /* bits += 16 */
451 shll %cl, %eax
452 orl %eax, hold_r /* hold |= *((ushort *)in)++ << bits */
453
454.L_get_length_code:
455 movl lmask(%esp), %edx /* edx = lmask */
456 movl lcode(%esp), %ecx /* ecx = lcode */
457 andl hold_r, %edx /* edx &= hold */
458 movl (%ecx,%edx,4), %eax /* eax = lcode[hold & lmask] */
459
460.L_dolen:
461 /* regs: %esi = in, %ebp = hold, %bl = bits, %edi = out
462 *
463 * dolen:
464 * bits -= this.bits;
465 * hold >>= this.bits
466 */
467 movb %ah, %cl /* cl = this.bits */
468 subb %ah, bits_r /* bits -= this.bits */
469 shrl %cl, hold_r /* hold >>= this.bits */
470
471 /* check if op is a literal
472 * if (op == 0) {
473 * PUP(out) = this.val;
474 * }
475 */
476 testb %al, %al
477 jnz .L_test_for_length_base /* if (op != 0) 45.7% */
478
479 shrl $16, %eax /* output this.val char */
480 stosb
481 jmp .L_while_test
482
483.L_test_for_length_base:
484 /* regs: %esi = in, %ebp = hold, %bl = bits, %edi = out, %edx = len
485 *
486 * else if (op & 16) {
487 * len = this.val
488 * op &= 15
489 * if (op) {
490 * if (op > bits) {
491 * hold |= *((unsigned short *)in)++ << bits;
492 * bits += 16
493 * }
494 * len += hold & mask[op];
495 * bits -= op;
496 * hold >>= op;
497 * }
498 */
499#define len_r %edx
500 movl %eax, len_r /* len = this */
501 shrl $16, len_r /* len = this.val */
502 movb %al, %cl
503
504 testb $16, %al
505 jz .L_test_for_second_level_length /* if ((op & 16) == 0) 8% */
506 andb $15, %cl /* op &= 15 */
507 jz .L_save_len /* if (!op) */
508 cmpb %cl, bits_r
509 jae .L_add_bits_to_len /* if (op <= bits) */
510
511 movb %cl, %ch /* stash op in ch, freeing cl */
512 xorl %eax, %eax
513 lodsw /* al = *(ushort *)in++ */
514 movb bits_r, %cl /* cl = bits, needs it for shifting */
515 addb $16, bits_r /* bits += 16 */
516 shll %cl, %eax
517 orl %eax, hold_r /* hold |= *((ushort *)in)++ << bits */
518 movb %ch, %cl /* move op back to ecx */
519
520.L_add_bits_to_len:
521 movl $1, %eax
522 shll %cl, %eax
523 decl %eax
524 subb %cl, bits_r
525 andl hold_r, %eax /* eax &= hold */
526 shrl %cl, hold_r
527 addl %eax, len_r /* len += hold & mask[op] */
528
529.L_save_len:
530 movl len_r, len(%esp) /* save len */
531#undef len_r
532
533.L_decode_distance:
534 /* regs: %esi = in, %ebp = hold, %bl = bits, %edi = out, %edx = dist
535 *
536 * if (bits < 15) {
537 * hold |= *((unsigned short *)in)++ << bits;
538 * bits += 16
539 * }
540 * this = dcode[hold & dmask];
541 * dodist:
542 * bits -= this.bits;
543 * hold >>= this.bits;
544 * op = this.op;
545 */
546
547 cmpb $15, bits_r
548 ja .L_get_distance_code /* if (15 < bits) */
549
550 xorl %eax, %eax
551 lodsw /* al = *(ushort *)in++ */
552 movb bits_r, %cl /* cl = bits, needs it for shifting */
553 addb $16, bits_r /* bits += 16 */
554 shll %cl, %eax
555 orl %eax, hold_r /* hold |= *((ushort *)in)++ << bits */
556
557.L_get_distance_code:
558 movl dmask(%esp), %edx /* edx = dmask */
559 movl dcode(%esp), %ecx /* ecx = dcode */
560 andl hold_r, %edx /* edx &= hold */
561 movl (%ecx,%edx,4), %eax /* eax = dcode[hold & dmask] */
562
563#define dist_r %edx
564.L_dodist:
565 movl %eax, dist_r /* dist = this */
566 shrl $16, dist_r /* dist = this.val */
567 movb %ah, %cl
568 subb %ah, bits_r /* bits -= this.bits */
569 shrl %cl, hold_r /* hold >>= this.bits */
570
571 /* if (op & 16) {
572 * dist = this.val
573 * op &= 15
574 * if (op > bits) {
575 * hold |= *((unsigned short *)in)++ << bits;
576 * bits += 16
577 * }
578 * dist += hold & mask[op];
579 * bits -= op;
580 * hold >>= op;
581 */
582 movb %al, %cl /* cl = this.op */
583
584 testb $16, %al /* if ((op & 16) == 0) */
585 jz .L_test_for_second_level_dist
586 andb $15, %cl /* op &= 15 */
587 jz .L_check_dist_one
588 cmpb %cl, bits_r
589 jae .L_add_bits_to_dist /* if (op <= bits) 97.6% */
590
591 movb %cl, %ch /* stash op in ch, freeing cl */
592 xorl %eax, %eax
593 lodsw /* al = *(ushort *)in++ */
594 movb bits_r, %cl /* cl = bits, needs it for shifting */
595 addb $16, bits_r /* bits += 16 */
596 shll %cl, %eax
597 orl %eax, hold_r /* hold |= *((ushort *)in)++ << bits */
598 movb %ch, %cl /* move op back to ecx */
599
600.L_add_bits_to_dist:
601 movl $1, %eax
602 shll %cl, %eax
603 decl %eax /* (1 << op) - 1 */
604 subb %cl, bits_r
605 andl hold_r, %eax /* eax &= hold */
606 shrl %cl, hold_r
607 addl %eax, dist_r /* dist += hold & ((1 << op) - 1) */
608 jmp .L_check_window
609
610.L_check_window:
611 /* regs: %esi = from, %ebp = hold, %bl = bits, %edi = out, %edx = dist
612 * %ecx = nbytes
613 *
614 * nbytes = out - beg;
615 * if (dist <= nbytes) {
616 * from = out - dist;
617 * do {
618 * PUP(out) = PUP(from);
619 * } while (--len > 0) {
620 * }
621 */
622
623 movl in_r, in(%esp) /* save in so from can use it's reg */
624 movl out_r, %eax
625 subl beg(%esp), %eax /* nbytes = out - beg */
626
627 cmpl dist_r, %eax
628 jb .L_clip_window /* if (dist > nbytes) 4.2% */
629
630 movl len(%esp), %ecx
631 movl out_r, from_r
632 subl dist_r, from_r /* from = out - dist */
633
634 subl $3, %ecx
635 movb (from_r), %al
636 movb %al, (out_r)
637 movb 1(from_r), %al
638 movb 2(from_r), %dl
639 addl $3, from_r
640 movb %al, 1(out_r)
641 movb %dl, 2(out_r)
642 addl $3, out_r
643 rep movsb
644
645 movl in(%esp), in_r /* move in back to %esi, toss from */
646 jmp .L_while_test
647
648.align 16,0x90
649.L_check_dist_one:
650 cmpl $1, dist_r
651 jne .L_check_window
652 cmpl out_r, beg(%esp)
653 je .L_check_window
654
655 decl out_r
656 movl len(%esp), %ecx
657 movb (out_r), %al
658 subl $3, %ecx
659
660 movb %al, 1(out_r)
661 movb %al, 2(out_r)
662 movb %al, 3(out_r)
663 addl $4, out_r
664 rep stosb
665
666 jmp .L_while_test
667
668.align 16,0x90
669.L_test_for_second_level_length:
670 /* else if ((op & 64) == 0) {
671 * this = lcode[this.val + (hold & mask[op])];
672 * }
673 */
674 testb $64, %al
675 jnz .L_test_for_end_of_block /* if ((op & 64) != 0) */
676
677 movl $1, %eax
678 shll %cl, %eax
679 decl %eax
680 andl hold_r, %eax /* eax &= hold */
681 addl %edx, %eax /* eax += this.val */
682 movl lcode(%esp), %edx /* edx = lcode */
683 movl (%edx,%eax,4), %eax /* eax = lcode[val + (hold&mask[op])] */
684 jmp .L_dolen
685
686.align 16,0x90
687.L_test_for_second_level_dist:
688 /* else if ((op & 64) == 0) {
689 * this = dcode[this.val + (hold & mask[op])];
690 * }
691 */
692 testb $64, %al
693 jnz .L_invalid_distance_code /* if ((op & 64) != 0) */
694
695 movl $1, %eax
696 shll %cl, %eax
697 decl %eax
698 andl hold_r, %eax /* eax &= hold */
699 addl %edx, %eax /* eax += this.val */
700 movl dcode(%esp), %edx /* edx = dcode */
701 movl (%edx,%eax,4), %eax /* eax = dcode[val + (hold&mask[op])] */
702 jmp .L_dodist
703
704.align 16,0x90
705.L_clip_window:
706 /* regs: %esi = from, %ebp = hold, %bl = bits, %edi = out, %edx = dist
707 * %ecx = nbytes
708 *
709 * else {
710 * if (dist > wsize) {
711 * invalid distance
712 * }
713 * from = window;
714 * nbytes = dist - nbytes;
715 * if (write == 0) {
716 * from += wsize - nbytes;
717 */
718#define nbytes_r %ecx
719 movl %eax, nbytes_r
720 movl wsize(%esp), %eax /* prepare for dist compare */
721 negl nbytes_r /* nbytes = -nbytes */
722 movl window(%esp), from_r /* from = window */
723
724 cmpl dist_r, %eax
725 jb .L_invalid_distance_too_far /* if (dist > wsize) */
726
727 addl dist_r, nbytes_r /* nbytes = dist - nbytes */
728 cmpl $0, write(%esp)
729 jne .L_wrap_around_window /* if (write != 0) */
730
731 subl nbytes_r, %eax
732 addl %eax, from_r /* from += wsize - nbytes */
733
734 /* regs: %esi = from, %ebp = hold, %bl = bits, %edi = out, %edx = dist
735 * %ecx = nbytes, %eax = len
736 *
737 * if (nbytes < len) {
738 * len -= nbytes;
739 * do {
740 * PUP(out) = PUP(from);
741 * } while (--nbytes);
742 * from = out - dist;
743 * }
744 * }
745 */
746#define len_r %eax
747 movl len(%esp), len_r
748 cmpl nbytes_r, len_r
749 jbe .L_do_copy1 /* if (nbytes >= len) */
750
751 subl nbytes_r, len_r /* len -= nbytes */
752 rep movsb
753 movl out_r, from_r
754 subl dist_r, from_r /* from = out - dist */
755 jmp .L_do_copy1
756
757 cmpl nbytes_r, len_r
758 jbe .L_do_copy1 /* if (nbytes >= len) */
759
760 subl nbytes_r, len_r /* len -= nbytes */
761 rep movsb
762 movl out_r, from_r
763 subl dist_r, from_r /* from = out - dist */
764 jmp .L_do_copy1
765
766.L_wrap_around_window:
767 /* regs: %esi = from, %ebp = hold, %bl = bits, %edi = out, %edx = dist
768 * %ecx = nbytes, %eax = write, %eax = len
769 *
770 * else if (write < nbytes) {
771 * from += wsize + write - nbytes;
772 * nbytes -= write;
773 * if (nbytes < len) {
774 * len -= nbytes;
775 * do {
776 * PUP(out) = PUP(from);
777 * } while (--nbytes);
778 * from = window;
779 * nbytes = write;
780 * if (nbytes < len) {
781 * len -= nbytes;
782 * do {
783 * PUP(out) = PUP(from);
784 * } while(--nbytes);
785 * from = out - dist;
786 * }
787 * }
788 * }
789 */
790#define write_r %eax
791 movl write(%esp), write_r
792 cmpl write_r, nbytes_r
793 jbe .L_contiguous_in_window /* if (write >= nbytes) */
794
795 addl wsize(%esp), from_r
796 addl write_r, from_r
797 subl nbytes_r, from_r /* from += wsize + write - nbytes */
798 subl write_r, nbytes_r /* nbytes -= write */
799#undef write_r
800
801 movl len(%esp), len_r
802 cmpl nbytes_r, len_r
803 jbe .L_do_copy1 /* if (nbytes >= len) */
804
805 subl nbytes_r, len_r /* len -= nbytes */
806 rep movsb
807 movl window(%esp), from_r /* from = window */
808 movl write(%esp), nbytes_r /* nbytes = write */
809 cmpl nbytes_r, len_r
810 jbe .L_do_copy1 /* if (nbytes >= len) */
811
812 subl nbytes_r, len_r /* len -= nbytes */
813 rep movsb
814 movl out_r, from_r
815 subl dist_r, from_r /* from = out - dist */
816 jmp .L_do_copy1
817
818.L_contiguous_in_window:
819 /* regs: %esi = from, %ebp = hold, %bl = bits, %edi = out, %edx = dist
820 * %ecx = nbytes, %eax = write, %eax = len
821 *
822 * else {
823 * from += write - nbytes;
824 * if (nbytes < len) {
825 * len -= nbytes;
826 * do {
827 * PUP(out) = PUP(from);
828 * } while (--nbytes);
829 * from = out - dist;
830 * }
831 * }
832 */
833#define write_r %eax
834 addl write_r, from_r
835 subl nbytes_r, from_r /* from += write - nbytes */
836#undef write_r
837
838 movl len(%esp), len_r
839 cmpl nbytes_r, len_r
840 jbe .L_do_copy1 /* if (nbytes >= len) */
841
842 subl nbytes_r, len_r /* len -= nbytes */
843 rep movsb
844 movl out_r, from_r
845 subl dist_r, from_r /* from = out - dist */
846
847.L_do_copy1:
848 /* regs: %esi = from, %esi = in, %ebp = hold, %bl = bits, %edi = out
849 * %eax = len
850 *
851 * while (len > 0) {
852 * PUP(out) = PUP(from);
853 * len--;
854 * }
855 * }
856 * } while (in < last && out < end);
857 */
858#undef nbytes_r
859#define in_r %esi
860 movl len_r, %ecx
861 rep movsb
862
863 movl in(%esp), in_r /* move in back to %esi, toss from */
864 jmp .L_while_test
865
866#undef len_r
867#undef dist_r
868
869#endif /* NO_MMX || RUN_TIME_MMX */
870
871
872/*** MMX code ***/
873
874#if defined( USE_MMX ) || defined( RUN_TIME_MMX )
875
876.align 32,0x90
877.L_init_mmx:
878 emms
879
880#undef bits_r
881#undef bitslong_r
882#define bitslong_r %ebp
883#define hold_mm %mm0
884 movd %ebp, hold_mm
885 movl %ebx, bitslong_r
886
887#define used_mm %mm1
888#define dmask2_mm %mm2
889#define lmask2_mm %mm3
890#define lmask_mm %mm4
891#define dmask_mm %mm5
892#define tmp_mm %mm6
893
894 movd lmask(%esp), lmask_mm
895 movq lmask_mm, lmask2_mm
896 movd dmask(%esp), dmask_mm
897 movq dmask_mm, dmask2_mm
898 pxor used_mm, used_mm
899 movl lcode(%esp), %ebx /* ebx = lcode */
900 jmp .L_do_loop_mmx
901
902.align 32,0x90
903.L_while_test_mmx:
904 /* while (in < last && out < end)
905 */
906 cmpl out_r, end(%esp)
907 jbe .L_break_loop /* if (out >= end) */
908
909 cmpl in_r, last(%esp)
910 jbe .L_break_loop
911
912.L_do_loop_mmx:
913 psrlq used_mm, hold_mm /* hold_mm >>= last bit length */
914
915 cmpl $32, bitslong_r
916 ja .L_get_length_code_mmx /* if (32 < bits) */
917
918 movd bitslong_r, tmp_mm
919 movd (in_r), %mm7
920 addl $4, in_r
921 psllq tmp_mm, %mm7
922 addl $32, bitslong_r
923 por %mm7, hold_mm /* hold_mm |= *((uint *)in)++ << bits */
924
925.L_get_length_code_mmx:
926 pand hold_mm, lmask_mm
927 movd lmask_mm, %eax
928 movq lmask2_mm, lmask_mm
929 movl (%ebx,%eax,4), %eax /* eax = lcode[hold & lmask] */
930
931.L_dolen_mmx:
932 movzbl %ah, %ecx /* ecx = this.bits */
933 movd %ecx, used_mm
934 subl %ecx, bitslong_r /* bits -= this.bits */
935
936 testb %al, %al
937 jnz .L_test_for_length_base_mmx /* if (op != 0) 45.7% */
938
939 shrl $16, %eax /* output this.val char */
940 stosb
941 jmp .L_while_test_mmx
942
943.L_test_for_length_base_mmx:
944#define len_r %edx
945 movl %eax, len_r /* len = this */
946 shrl $16, len_r /* len = this.val */
947
948 testb $16, %al
949 jz .L_test_for_second_level_length_mmx /* if ((op & 16) == 0) 8% */
950 andl $15, %eax /* op &= 15 */
951 jz .L_decode_distance_mmx /* if (!op) */
952
953 psrlq used_mm, hold_mm /* hold_mm >>= last bit length */
954 movd %eax, used_mm
955 movd hold_mm, %ecx
956 subl %eax, bitslong_r
957 andl .L_mask(,%eax,4), %ecx
958 addl %ecx, len_r /* len += hold & mask[op] */
959
960.L_decode_distance_mmx:
961 psrlq used_mm, hold_mm /* hold_mm >>= last bit length */
962
963 cmpl $32, bitslong_r
964 ja .L_get_dist_code_mmx /* if (32 < bits) */
965
966 movd bitslong_r, tmp_mm
967 movd (in_r), %mm7
968 addl $4, in_r
969 psllq tmp_mm, %mm7
970 addl $32, bitslong_r
971 por %mm7, hold_mm /* hold_mm |= *((uint *)in)++ << bits */
972
973.L_get_dist_code_mmx:
974 movl dcode(%esp), %ebx /* ebx = dcode */
975 pand hold_mm, dmask_mm
976 movd dmask_mm, %eax
977 movq dmask2_mm, dmask_mm
978 movl (%ebx,%eax,4), %eax /* eax = dcode[hold & lmask] */
979
980.L_dodist_mmx:
981#define dist_r %ebx
982 movzbl %ah, %ecx /* ecx = this.bits */
983 movl %eax, dist_r
984 shrl $16, dist_r /* dist = this.val */
985 subl %ecx, bitslong_r /* bits -= this.bits */
986 movd %ecx, used_mm
987
988 testb $16, %al /* if ((op & 16) == 0) */
989 jz .L_test_for_second_level_dist_mmx
990 andl $15, %eax /* op &= 15 */
991 jz .L_check_dist_one_mmx
992
993.L_add_bits_to_dist_mmx:
994 psrlq used_mm, hold_mm /* hold_mm >>= last bit length */
995 movd %eax, used_mm /* save bit length of current op */
996 movd hold_mm, %ecx /* get the next bits on input stream */
997 subl %eax, bitslong_r /* bits -= op bits */
998 andl .L_mask(,%eax,4), %ecx /* ecx = hold & mask[op] */
999 addl %ecx, dist_r /* dist += hold & mask[op] */
1000
1001.L_check_window_mmx:
1002 movl in_r, in(%esp) /* save in so from can use it's reg */
1003 movl out_r, %eax
1004 subl beg(%esp), %eax /* nbytes = out - beg */
1005
1006 cmpl dist_r, %eax
1007 jb .L_clip_window_mmx /* if (dist > nbytes) 4.2% */
1008
1009 movl len_r, %ecx
1010 movl out_r, from_r
1011 subl dist_r, from_r /* from = out - dist */
1012
1013 subl $3, %ecx
1014 movb (from_r), %al
1015 movb %al, (out_r)
1016 movb 1(from_r), %al
1017 movb 2(from_r), %dl
1018 addl $3, from_r
1019 movb %al, 1(out_r)
1020 movb %dl, 2(out_r)
1021 addl $3, out_r
1022 rep movsb
1023
1024 movl in(%esp), in_r /* move in back to %esi, toss from */
1025 movl lcode(%esp), %ebx /* move lcode back to %ebx, toss dist */
1026 jmp .L_while_test_mmx
1027
1028.align 16,0x90
1029.L_check_dist_one_mmx:
1030 cmpl $1, dist_r
1031 jne .L_check_window_mmx
1032 cmpl out_r, beg(%esp)
1033 je .L_check_window_mmx
1034
1035 decl out_r
1036 movl len_r, %ecx
1037 movb (out_r), %al
1038 subl $3, %ecx
1039
1040 movb %al, 1(out_r)
1041 movb %al, 2(out_r)
1042 movb %al, 3(out_r)
1043 addl $4, out_r
1044 rep stosb
1045
1046 movl lcode(%esp), %ebx /* move lcode back to %ebx, toss dist */
1047 jmp .L_while_test_mmx
1048
1049.align 16,0x90
1050.L_test_for_second_level_length_mmx:
1051 testb $64, %al
1052 jnz .L_test_for_end_of_block /* if ((op & 64) != 0) */
1053
1054 andl $15, %eax
1055 psrlq used_mm, hold_mm /* hold_mm >>= last bit length */
1056 movd hold_mm, %ecx
1057 andl .L_mask(,%eax,4), %ecx
1058 addl len_r, %ecx
1059 movl (%ebx,%ecx,4), %eax /* eax = lcode[hold & lmask] */
1060 jmp .L_dolen_mmx
1061
1062.align 16,0x90
1063.L_test_for_second_level_dist_mmx:
1064 testb $64, %al
1065 jnz .L_invalid_distance_code /* if ((op & 64) != 0) */
1066
1067 andl $15, %eax
1068 psrlq used_mm, hold_mm /* hold_mm >>= last bit length */
1069 movd hold_mm, %ecx
1070 andl .L_mask(,%eax,4), %ecx
1071 movl dcode(%esp), %eax /* ecx = dcode */
1072 addl dist_r, %ecx
1073 movl (%eax,%ecx,4), %eax /* eax = lcode[hold & lmask] */
1074 jmp .L_dodist_mmx
1075
1076.align 16,0x90
1077.L_clip_window_mmx:
1078#define nbytes_r %ecx
1079 movl %eax, nbytes_r
1080 movl wsize(%esp), %eax /* prepare for dist compare */
1081 negl nbytes_r /* nbytes = -nbytes */
1082 movl window(%esp), from_r /* from = window */
1083
1084 cmpl dist_r, %eax
1085 jb .L_invalid_distance_too_far /* if (dist > wsize) */
1086
1087 addl dist_r, nbytes_r /* nbytes = dist - nbytes */
1088 cmpl $0, write(%esp)
1089 jne .L_wrap_around_window_mmx /* if (write != 0) */
1090
1091 subl nbytes_r, %eax
1092 addl %eax, from_r /* from += wsize - nbytes */
1093
1094 cmpl nbytes_r, len_r
1095 jbe .L_do_copy1_mmx /* if (nbytes >= len) */
1096
1097 subl nbytes_r, len_r /* len -= nbytes */
1098 rep movsb
1099 movl out_r, from_r
1100 subl dist_r, from_r /* from = out - dist */
1101 jmp .L_do_copy1_mmx
1102
1103 cmpl nbytes_r, len_r
1104 jbe .L_do_copy1_mmx /* if (nbytes >= len) */
1105
1106 subl nbytes_r, len_r /* len -= nbytes */
1107 rep movsb
1108 movl out_r, from_r
1109 subl dist_r, from_r /* from = out - dist */
1110 jmp .L_do_copy1_mmx
1111
1112.L_wrap_around_window_mmx:
1113#define write_r %eax
1114 movl write(%esp), write_r
1115 cmpl write_r, nbytes_r
1116 jbe .L_contiguous_in_window_mmx /* if (write >= nbytes) */
1117
1118 addl wsize(%esp), from_r
1119 addl write_r, from_r
1120 subl nbytes_r, from_r /* from += wsize + write - nbytes */
1121 subl write_r, nbytes_r /* nbytes -= write */
1122#undef write_r
1123
1124 cmpl nbytes_r, len_r
1125 jbe .L_do_copy1_mmx /* if (nbytes >= len) */
1126
1127 subl nbytes_r, len_r /* len -= nbytes */
1128 rep movsb
1129 movl window(%esp), from_r /* from = window */
1130 movl write(%esp), nbytes_r /* nbytes = write */
1131 cmpl nbytes_r, len_r
1132 jbe .L_do_copy1_mmx /* if (nbytes >= len) */
1133
1134 subl nbytes_r, len_r /* len -= nbytes */
1135 rep movsb
1136 movl out_r, from_r
1137 subl dist_r, from_r /* from = out - dist */
1138 jmp .L_do_copy1_mmx
1139
1140.L_contiguous_in_window_mmx:
1141#define write_r %eax
1142 addl write_r, from_r
1143 subl nbytes_r, from_r /* from += write - nbytes */
1144#undef write_r
1145
1146 cmpl nbytes_r, len_r
1147 jbe .L_do_copy1_mmx /* if (nbytes >= len) */
1148
1149 subl nbytes_r, len_r /* len -= nbytes */
1150 rep movsb
1151 movl out_r, from_r
1152 subl dist_r, from_r /* from = out - dist */
1153
1154.L_do_copy1_mmx:
1155#undef nbytes_r
1156#define in_r %esi
1157 movl len_r, %ecx
1158 rep movsb
1159
1160 movl in(%esp), in_r /* move in back to %esi, toss from */
1161 movl lcode(%esp), %ebx /* move lcode back to %ebx, toss dist */
1162 jmp .L_while_test_mmx
1163
1164#undef hold_r
1165#undef bitslong_r
1166
1167#endif /* USE_MMX || RUN_TIME_MMX */
1168
1169
1170/*** USE_MMX, NO_MMX, and RUNTIME_MMX from here on ***/
1171
1172.L_invalid_distance_code:
1173 /* else {
1174 * strm->msg = "invalid distance code";
1175 * state->mode = BAD;
1176 * }
1177 */
1178 movl $.L_invalid_distance_code_msg, %ecx
1179 movl $INFLATE_MODE_BAD, %edx
1180 jmp .L_update_stream_state
1181
1182.L_test_for_end_of_block:
1183 /* else if (op & 32) {
1184 * state->mode = TYPE;
1185 * break;
1186 * }
1187 */
1188 testb $32, %al
1189 jz .L_invalid_literal_length_code /* if ((op & 32) == 0) */
1190
1191 movl $0, %ecx
1192 movl $INFLATE_MODE_TYPE, %edx
1193 jmp .L_update_stream_state
1194
1195.L_invalid_literal_length_code:
1196 /* else {
1197 * strm->msg = "invalid literal/length code";
1198 * state->mode = BAD;
1199 * }
1200 */
1201 movl $.L_invalid_literal_length_code_msg, %ecx
1202 movl $INFLATE_MODE_BAD, %edx
1203 jmp .L_update_stream_state
1204
1205.L_invalid_distance_too_far:
1206 /* strm->msg = "invalid distance too far back";
1207 * state->mode = BAD;
1208 */
1209 movl in(%esp), in_r /* from_r has in's reg, put in back */
1210 movl $.L_invalid_distance_too_far_msg, %ecx
1211 movl $INFLATE_MODE_BAD, %edx
1212 jmp .L_update_stream_state
1213
1214.L_update_stream_state:
1215 /* set strm->msg = %ecx, strm->state->mode = %edx */
1216 movl strm_sp(%esp), %eax
1217 testl %ecx, %ecx /* if (msg != NULL) */
1218 jz .L_skip_msg
1219 movl %ecx, msg_strm(%eax) /* strm->msg = msg */
1220.L_skip_msg:
1221 movl state_strm(%eax), %eax /* state = strm->state */
1222 movl %edx, mode_state(%eax) /* state->mode = edx (BAD | TYPE) */
1223 jmp .L_break_loop
1224
1225.align 32,0x90
1226.L_break_loop:
1227
1228/*
1229 * Regs:
1230 *
1231 * bits = %ebp when mmx, and in %ebx when non-mmx
1232 * hold = %hold_mm when mmx, and in %ebp when non-mmx
1233 * in = %esi
1234 * out = %edi
1235 */
1236
1237#if defined( USE_MMX ) || defined( RUN_TIME_MMX )
1238
1239#if defined( RUN_TIME_MMX )
1240
1241 cmpl $DO_USE_MMX, inflate_fast_use_mmx
1242 jne .L_update_next_in
1243
1244#endif /* RUN_TIME_MMX */
1245
1246 movl %ebp, %ebx
1247
1248.L_update_next_in:
1249
1250#endif
1251
1252#define strm_r %eax
1253#define state_r %edx
1254
1255 /* len = bits >> 3;
1256 * in -= len;
1257 * bits -= len << 3;
1258 * hold &= (1U << bits) - 1;
1259 * state->hold = hold;
1260 * state->bits = bits;
1261 * strm->next_in = in;
1262 * strm->next_out = out;
1263 */
1264 movl strm_sp(%esp), strm_r
1265 movl %ebx, %ecx
1266 movl state_strm(strm_r), state_r
1267 shrl $3, %ecx
1268 subl %ecx, in_r
1269 shll $3, %ecx
1270 subl %ecx, %ebx
1271 movl out_r, next_out_strm(strm_r)
1272 movl %ebx, bits_state(state_r)
1273 movl %ebx, %ecx
1274
1275 leal buf(%esp), %ebx
1276 cmpl %ebx, last(%esp)
1277 jne .L_buf_not_used /* if buf != last */
1278
1279 subl %ebx, in_r /* in -= buf */
1280 movl next_in_strm(strm_r), %ebx
1281 movl %ebx, last(%esp) /* last = strm->next_in */
1282 addl %ebx, in_r /* in += strm->next_in */
1283 movl avail_in_strm(strm_r), %ebx
1284 subl $11, %ebx
1285 addl %ebx, last(%esp) /* last = &strm->next_in[ avail_in - 11 ] */
1286
1287.L_buf_not_used:
1288 movl in_r, next_in_strm(strm_r)
1289
1290 movl $1, %ebx
1291 shll %cl, %ebx
1292 decl %ebx
1293
1294#if defined( USE_MMX ) || defined( RUN_TIME_MMX )
1295
1296#if defined( RUN_TIME_MMX )
1297
1298 cmpl $DO_USE_MMX, inflate_fast_use_mmx
1299 jne .L_update_hold
1300
1301#endif /* RUN_TIME_MMX */
1302
1303 psrlq used_mm, hold_mm /* hold_mm >>= last bit length */
1304 movd hold_mm, %ebp
1305
1306 emms
1307
1308.L_update_hold:
1309
1310#endif /* USE_MMX || RUN_TIME_MMX */
1311
1312 andl %ebx, %ebp
1313 movl %ebp, hold_state(state_r)
1314
1315#define last_r %ebx
1316
1317 /* strm->avail_in = in < last ? 11 + (last - in) : 11 - (in - last) */
1318 movl last(%esp), last_r
1319 cmpl in_r, last_r
1320 jbe .L_last_is_smaller /* if (in >= last) */
1321
1322 subl in_r, last_r /* last -= in */
1323 addl $11, last_r /* last += 11 */
1324 movl last_r, avail_in_strm(strm_r)
1325 jmp .L_fixup_out
1326.L_last_is_smaller:
1327 subl last_r, in_r /* in -= last */
1328 negl in_r /* in = -in */
1329 addl $11, in_r /* in += 11 */
1330 movl in_r, avail_in_strm(strm_r)
1331
1332#undef last_r
1333#define end_r %ebx
1334
1335.L_fixup_out:
1336 /* strm->avail_out = out < end ? 257 + (end - out) : 257 - (out - end)*/
1337 movl end(%esp), end_r
1338 cmpl out_r, end_r
1339 jbe .L_end_is_smaller /* if (out >= end) */
1340
1341 subl out_r, end_r /* end -= out */
1342 addl $257, end_r /* end += 257 */
1343 movl end_r, avail_out_strm(strm_r)
1344 jmp .L_done
1345.L_end_is_smaller:
1346 subl end_r, out_r /* out -= end */
1347 negl out_r /* out = -out */
1348 addl $257, out_r /* out += 257 */
1349 movl out_r, avail_out_strm(strm_r)
1350
1351#undef end_r
1352#undef strm_r
1353#undef state_r
1354
1355.L_done:
1356 addl $local_var_size, %esp
1357 popf
1358 popl %ebx
1359 popl %ebp
1360 popl %esi
1361 popl %edi
1362 ret
1363
1364#if defined( GAS_ELF )
1365/* elf info */
1366.type inflate_fast,@function
1367.size inflate_fast,.-inflate_fast
1368#endif
Note: See TracBrowser for help on using the repository browser.