--- /dev/null
+#if (defined __i386__)
+
+/* this assembly was 1st compiled from inffast.c (assuming POSTINC defined, OFF=0) and then hand optimized */
+
+ .cstring
+LC0:
+ .ascii "invalid distance too far back\0"
+LC1:
+ .ascii "invalid distance code\0"
+LC2:
+ .ascii "invalid literal/length code\0"
+ .text
+ .align 4,0x90
+
+
+#ifdef INFLATE_STRICT
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+#endif
+.globl _inflate_fast
+_inflate_fast:
+
+ // set up ebp to refer to arguments strm and start
+ pushl %ebp
+ movl %esp, %ebp
+
+ // push edi/esi/ebx into stack
+ pushl %edi
+ pushl %esi
+ pushl %ebx
+
+ // allocate for local variables 92-12=80, + 12 to align %esp to 16-byte boundary
+ subl $92, %esp
+ movl 8(%ebp), %ebx
+
+ /* definitions to help code readability */
+
+ #define bits %edi
+ #define strm %ebx
+ #define state 28(strm) // state = (struct inflate_state FAR *)strm->state;
+ #define in -84(%ebp) // in = strm->next_in - OFF; OFF=0
+ #define last -80(%ebp) // last = in + (strm->avail_in - 5);
+ #define out -28(%ebp) // out = strm->next_out - OFF;
+ #define beg -76(%ebp) // beg = out - (start - strm->avail_out);
+ #define end -72(%ebp) // end = out + (strm->avail_out - 257);
+ #define wsize -68(%ebp) // wsize = state->wsize;
+ #define whave -64(%ebp) // whave = state->whave;
+ #define write -60(%ebp) // write = state->write;
+ #define window -56(%ebp) // window = state->window;
+ #define hold -52(%ebp) // hold = state->hold;
+ #define lcode -48(%ebp) // lcode = state->lencode;
+ #define dcode -44(%ebp) // dcode = state->distcode;
+ #define lmask -40(%ebp) // lmask = (1U << state->lenbits) - 1;
+ #define dmask -36(%ebp) // dmask = (1U << state->distbits) - 1;
+ #define len -32(%ebp)
+ #define dmax -20(%ebp)
+ #define dist -16(%ebp) // dist
+ #define write_wsize -24(%ebp) // write+wsize
+ #define write_1 -88(%ebp) // write-1
+ #define op -92(%ebp) // op
+
+ movl (strm), %eax // strm->next_in
+ movl %eax, in // in = strm->next_in - OFF; OFF=0
+
+ subl $5, %eax // in - 5;
+ movl 4(strm), %ecx // strm->avail_in
+ addl %ecx, %eax // in + (strm->avail_in - 5);
+ movl %eax, last // last = in + (strm->avail_in - 5);
+
+ movl 12(strm), %esi // strm->next_out
+ movl %esi, out // out = strm->next_out - OFF;
+
+ movl 16(strm), %ecx // strm->avail_out
+ movl %esi, %eax // out
+ subl 12(%ebp), %eax // out - start
+ addl %ecx, %eax // out - (start - strm->avail_out);
+ movl %eax, beg // beg = out - (start - strm->avail_out);
+
+ leal -257(%esi,%ecx), %ecx // out + (strm->avail_out - 257);
+ movl %ecx, end // end = out + (strm->avail_out - 257);
+
+ movl state, %edx
+
+#ifdef INFLATE_STRICT
+ movl 20(%edx), %ecx // state->dmax
+ movl %ecx, dmax // dmax = state->dmax;
+#endif
+
+ movl 40(%edx), %ecx // state->wsize
+ movl %ecx, wsize // wsize = state->wsize;
+
+ movl 44(%edx), %ecx // state->whave
+ movl %ecx, whave // whave = state->whave;
+
+ movl 48(%edx), %esi // state->write
+ movl %esi, write // write = state->write;
+
+ movl 52(%edx), %eax // state->window
+ movl %eax, window // window = state->window;
+
+
+ movl 56(%edx), %ecx // state->hold
+ movl %ecx, hold // hold = state->hold
+
+ movl 60(%edx), bits // bits = state->bits;
+
+ movl 76(%edx), %esi // state->lencode
+ movl %esi, lcode // lcode = state->lencode;
+
+ movl 80(%edx), %eax // state->distcode
+ movl %eax, dcode // dcode = state->distcode;
+
+ movl 84(%edx), %ecx // state->lenbits
+ movl $1, %eax
+ movl %eax, %esi // a copy of 1
+ sall %cl, %esi // 1 << state->lenbits
+ decl %esi // (1U << state->lenbits) - 1;
+ movl %esi, lmask // lmask = (1U << state->lenbits) - 1;
+
+ movl 88(%edx), %ecx // state->distbits
+ sall %cl, %eax // 1 << state->distbits
+ decl %eax // (1U << state->distbits) - 1;
+ movl %eax, dmask // dmask = (1U << state->distbits) - 1;
+
+
+ // these 2 might be used often, precomputed and saved in stack
+ movl write, %eax
+ addl wsize, %eax
+ movl %eax, write_wsize // write+wsize
+
+ movl write, %edx
+ decl %edx
+ movl %edx, write_1 // write-1
+
+
+L_do_while_loop: // do {
+
+ cmpl $15, bits
+ jae bits_ge_15 // if (bits < 15) {
+#if 0
+ leal 8(bits), %esi // esi = bits+8
+ movl in, %eax // eax = in
+ movzbl (%eax), %edx // edx = *in++
+ movl bits, %ecx // cl = bits
+ sall %cl, %edx // 1st *in << bits
+ addl hold, %edx // hold += 1st *in << bits
+ movzbl 1(%eax), %eax // 2nd *in
+ movl %esi, %ecx // cl = bits+8
+ sall %cl, %eax // 2nd *in << (bits+8)
+ addl %eax, %edx // hold += 2nd *in << (bits+8)
+ movl %edx, hold // update hold
+ addl $2, in // in += 2
+ addl $16, bits // bits += 16;
+#else
+ /* from simulation, this code segment performs better than the other case
+ possibly, we are more often hit with aligned memory access */
+ movl in, %ecx // unsigned short *inp = (unsigned short *) (in+OFF);
+ movzwl (%ecx), %eax // *((unsigned short *) in);
+ movl bits, %ecx // bits
+ sall %cl, %eax // *((unsigned short *) in) << bits
+ addl %eax, hold // hold += (unsigned long) *((unsigned short *) in) << bits;
+ addl $2, in // in += 2;
+ addl $16, bits // bits += 16;
+#endif
+
+bits_ge_15: // } /* bits < 15 */
+
+ movl hold, %eax // hold
+ andl lmask, %eax // hold & lmask;
+ movl lcode, %esi // lcode[] : 4-byte aligned
+ movl (%esi,%eax,4), %eax // this = lcode[hold&lmask];
+ jmp dolen
+ .align 4,0x90
+op_nonzero:
+ movzbl %al, %ecx // a copy of op to cl
+ testb $16, %cl // if op&16
+ jne Llength_base // branch to length_base
+
+ testb $64, %cl // elif op&64
+ jne length_2nd_level_else // branch to 2nd level length code else conditions
+
+ // 2nd level length code
+
+ movl $1, %eax
+ sall %cl, %eax // 1 << op
+ decl %eax // ((1<<op) - 1)
+ andl hold, %eax // hold & ((1U << op) - 1)
+ movzwl %si, %ecx // this.val
+ addl %ecx, %eax // this.val + (hold & ((1U << op) - 1))
+
+ movl lcode, %ecx // lcode[] : 4-byte aligned
+ movl (%ecx,%eax,4), %eax // this = lcode[this.val + (hold & ((1U << op) - 1))];
+ // goto dolen (compiler rearranged the order of code)
+dolen:
+ movl %eax, %esi // make a copy of this (val 16-bit, bits 8-bit, op 8-bit)
+ shrl $16, %esi // %esi = this.val;
+ movzbl %ah, %ecx // op = (unsigned)(this.bits);
+ shrl %cl, hold // hold >>= op;
+ subl %ecx, bits // bits -= op;
+ testb %al, %al // op = (unsigned)(this.op);
+ jne op_nonzero // if op!=0, branch to op_nonzero
+
+ movl %esi, %ecx // this.val;
+ movl out, %eax // out
+ movb %cl, (%eax) // PUP(out) = (unsigned char)(this.val);
+ incl %eax // out++;
+ movl %eax, out // save out
+
+L_tst_do_while_loop_end:
+ movl last, %eax // last
+ cmpl %eax, in // in vs last
+ jae return_unused_bytes // branch to return_unused_bytes if in >= last
+ movl end, %edx // end
+ cmpl %edx, out // out vs end
+ jb L_do_while_loop // branch to do loop if out < end
+
+return_unused_bytes:
+
+ movl bits, %eax // bits
+ shrl $3, %eax // len = bits >> 3
+ movl in, %edx // in
+ subl %eax, %edx // in -= len
+ sall $3, %eax // len << 3
+ movl bits, %ecx // bits
+ subl %eax, %ecx // bits -= len << 3
+
+ movl %edx, (strm) // strm->next_in = in + OFF;
+ movl out, %eax
+ movl %eax, 12(strm) // strm->next_out = out + OFF;
+
+ cmpl %edx, last // last vs in
+ jbe L67 // if (last <= in) branch to L67 and return to L69
+ movl last, %eax // last
+ addl $5, %eax // 5 + last
+ subl %edx, %eax // 5 + last - in
+L69:
+ movl %eax, 4(strm) // update strm->avail_in
+
+ movl end, %eax
+ cmpl %eax, out // out vs end
+ jae L70 // if (out>=end) branch to L70, and return to L72
+ addl $257, %eax // 257 + end
+ subl out, %eax // 257 + end - out
+L72:
+ movl %eax, 16(strm) // update strm->avail_out
+
+ movl $1, %eax
+ sall %cl, %eax // 1 << bits
+ decl %eax // (1 << bits) -1
+ andl hold, %eax // hold &= (1U << bits) - 1;
+ movl state, %esi
+ movl %eax, 56(%esi) // state->hold = hold;
+ movl %ecx, 60(%esi) // state->bits = bits;
+
+ addl $92, %esp // pop out local from stack
+
+ // restore saved registers and return
+ popl %ebx
+ popl %esi
+ popl %edi
+ leave
+ ret
+
+ // this code segment is branched in from op_nonzero, with op in cl and this.value in esi
+Llength_base:
+ movzwl %si, %esi // this instruction might not be needed, pad here to give better performance
+ movl %esi, len // len = (unsigned)(this.val);
+
+ movl %ecx, %esi // leave a copy of op at ecx
+ andl $15, %esi // op&=15;
+ je Lop_is_zero // if (op) {
+ cmpl bits, %esi // op vs bits
+ jbe Lop_be_bits // if (bits < op) {
+ movl in, %edx // in
+ movzbl (%edx), %eax // *in
+ movl bits, %ecx // bits
+ sall %cl, %eax // *in << bits
+ addl %eax, hold // hold += (unsigned long)(PUP(in)) << bits;
+ incl %edx // in++
+ movl %edx, in // update in
+ addl $8, bits // bits += 8
+Lop_be_bits: // }
+ movl $1, %eax // 1
+ movl %esi, %ecx // op
+ sall %cl, %eax // 1 << op
+ decl %eax // (1<<op)-1
+ andl hold, %eax // hold & ((1U << op) - 1)
+ addl %eax, len // len += (unsigned)hold & ((1U << op) - 1);
+ shrl %cl, hold // hold >>= op;
+ subl %esi, bits // bits -= op;
+Lop_is_zero: // }
+ cmpl $14, bits // if (bits < 15) {
+ jbe bits_le_14 // branch to refill 16-bit into hold, and branch back to next
+L19: // }
+ movl hold, %eax // hold
+ andl dmask, %eax // hold&dmask
+ movl dcode, %esi // dcode[] : 4-byte aligned
+ movl (%esi,%eax,4), %eax // this = dcode[hold & dmask];
+ jmp dodist
+
+Lop_16_zero:
+ testb $64, %cl // op&64
+ jne Linvalid_distance_code // if (op&64)!=0, branch to invalid distance code
+ movl $1, %eax // 1
+ sall %cl, %eax // (1<<op)
+ decl %eax // (1<<op)-1
+ andl hold, %eax // (hold & ((1U << op) - 1))
+ movzwl %dx, %edx // this.val
+ addl %edx, %eax // this.val + (hold & ((1U << op) - 1))
+ movl dcode, %edx // dcode[] : 4 byte aligned
+ movl (%edx,%eax,4), %eax // this = dcode[this.val + (hold & ((1U << op) - 1))];
+dodist:
+ movl %eax, %edx // this : (val 16-bit, bits 8-bit, op 8-bit)
+ shrl $16, %edx // edx = this.val
+ movzbl %ah, %ecx // op = (unsigned)(this.bits);
+ shrl %cl, hold // hold >>= op;
+ subl %ecx, bits // bits -= op;
+ movzbl %al, %ecx // op = (unsigned)(this.op);
+ testb $16, %cl // op & 16
+ je Lop_16_zero // if (op&16)==0 goto test op&64
+
+Ldistance_base: // if (op&16) { /* distance base */
+ andl $15, %ecx // op &= 15; edx = dist = this.val;
+ movl %ecx, op // save a copy of op
+ cmpl bits, %ecx // op vs bits
+ jbe 0f // if (bits < op) {
+ movl in, %ecx // in
+ movzbl (%ecx), %eax // *in
+ movl bits, %ecx // bits
+ sall %cl, %eax // *in << bits
+ addl %eax, hold // hold += (unsigned long)(PUP(in)) << bits;
+ incl in // in++
+ addl $8, bits // bits += 8
+ cmpl bits, op // op vs bits
+ jbe 0f // if (bits < op) {
+ movl in, %esi // i
+ movzbl (%esi), %eax // *in
+ movl bits, %ecx // cl = bits
+ sall %cl, %eax // *in << bits
+ addl %eax, hold // hold += (unsigned long)(PUP(in)) << bits;
+ incl %esi // in++
+ movl %esi, in // update in
+ addl $8, bits // bits += 8
+0: // } }
+
+ movzwl %dx, %edx // dist = (unsigned)(this.val);
+ movl $1, %eax // 1
+ movzbl op, %ecx // cl = op
+ sall %cl, %eax // 1 << op
+ decl %eax // ((1U << op) - 1)
+ andl hold, %eax // (unsigned)hold & ((1U << op) - 1)
+ addl %edx, %eax // dist += (unsigned)hold & ((1U << op) - 1);
+
+#ifdef INFLATE_STRICT
+
+ cmpl dmax, %eax // dist vs dmax
+ ja Linvalid_distance_too_far_back // if (dist > dmax) break for invalid distance too far back
+
+#endif
+
+ movl %eax, dist // save a copy of dist in stack
+ shrl %cl, hold // hold >>= op;
+ subl %ecx, bits // bits -= op;
+
+ movl out, %eax
+ subl beg, %eax // eax = op = out - beg
+ cmpl %eax, dist // dist vs op
+ jbe Lcopy_direct_from_output // if (dist <= op) branch to copy direct from output
+
+ // if (dist > op) {
+ movl dist, %ecx // dist
+ subl %eax, %ecx // esi = op = dist - op;
+ cmpl %ecx, whave // whave vs op
+ jb Linvalid_distance_too_far_back // if (op > whave) break for error;
+
+ movl write, %edx
+ testl %edx, %edx
+ jne Lwrite_non_zero // if (write==0) {
+ movl wsize, %eax // wsize
+ subl %ecx, %eax // wsize-op
+ movl window, %esi // from=window-OFF
+ addl %eax, %esi // from += wsize-op
+ movl out, %edx // out
+ cmpl %ecx, len // len vs op
+ jbe L38 // if !(op < len) skip
+ subl %ecx, len // len - op
+0: // do {
+ movzbl (%esi), %eax //
+ movb %al, (%edx) //
+ incl %edx //
+ incl %esi // PUP(out) = PUP(from);
+ decl %ecx // --op;
+ jne 0b // } while (op);
+
+ movl %edx, out // update out
+ movl %edx, %esi // out
+ subl dist, %esi // esi = from = out - dist;
+
+L38: /* copy from output */
+
+ // while (len > 2) {
+ // PUP(out) = PUP(from);
+ // PUP(out) = PUP(from);
+ // PUP(out) = PUP(from);
+ // len -= 3;
+ // }
+ // if (len) {
+ // PUP(out) = PUP(from);
+ // if (len > 1)
+ // PUP(out) = PUP(from);
+ // }
+
+ movl len, %ecx // len
+ movl out, %edx // out
+ subl $3, %ecx // pre-decrement len by 3
+ jl 1f // if len < 3, branch to 1f for remaining processing
+0: // while (len>2) {
+ movzbl (%esi), %eax
+ movb %al, (%edx) // PUP(out) = PUP(from);
+ movzbl 1(%esi), %eax
+ movb %al, 1(%edx) // PUP(out) = PUP(from);
+ movzbl 2(%esi), %eax
+ movb %al, 2(%edx) // PUP(out) = PUP(from);
+ addl $3, %esi // from += 3;
+ addl $3, %edx // out += 3;
+ subl $3, %ecx // len -= 3;
+ jge 0b // }
+ movl %edx, out // update out, in case len == 0
+1:
+ addl $3, %ecx // post-increment len by 3
+ je L_tst_do_while_loop_end // if (len) {
+ movzbl (%esi), %eax //
+ movb %al, (%edx) // PUP(out) = PUP(from);
+ incl %edx // out++
+ movl %edx, out // update out, in case len == 1
+ cmpl $2, %ecx //
+ jne L_tst_do_while_loop_end // if len==1, break
+ movzbl 1(%esi), %eax
+ movb %al, (%edx) // PUP(out) = PUP(from);
+ incl %edx // out++
+ movl %edx, out // update out
+ jmp L_tst_do_while_loop_end // }
+
+ .align 4,0x90
+length_2nd_level_else:
+ andl $32, %ecx // test end-of-block
+ je invalid_literal_length_code // if (op&32)==0, branch for invalid literal/length code break
+ movl state, %edx // if (op&32), end-of-block is detected
+ movl $11, (%edx) // state->mode = TYPE
+ jmp return_unused_bytes
+
+L70:
+ movl out, %edx // out
+ subl %edx, end // (end-out)
+ movl end, %esi // %esi = (end-out) = -(out - end);
+ leal 257(%esi), %eax // %eax = 257 + %esi = 257 - (out -end)
+ jmp L72 // return to update state and return
+
+L67: // %edx = in, to return 5 - (in - last) in %eax
+ subl %edx, last // last - in
+ movl last, %edx // %edx = last - in = - (in - last);
+ leal 5(%edx), %eax // %eax = 5 + %edx = 5 - (in - last);
+ jmp L69 // return to update state and return
+
+bits_le_14:
+#if 1
+ leal 8(bits), %esi // esi = bits+8
+ movl in, %eax // eax = in
+ movzbl (%eax), %edx // edx = *in++
+ movl bits, %ecx // cl = bits
+ sall %cl, %edx // 1st *in << bits
+ addl hold, %edx // hold += 1st *in << bits
+ movzbl 1(%eax), %eax // 2nd *in
+ movl %esi, %ecx // cl = bits+8
+ sall %cl, %eax // 2nd *in << (bits+8)
+ addl %eax, %edx // hold += 2nd *in << (bits+8)
+ movl %edx, hold // update hold
+ addl $2, in // in += 2
+ addl $16, bits // bits += 16;
+ jmp L19
+#else
+ /* this code segment does not run as fast as the other original code segment, possibly the processor
+ need extra time to handle unaligned short access */
+ movl in, %edx // unsigned short *inp = (unsigned short *) (in+OFF);
+ movzwl (%edx), %eax // *((unsigned short *) in);
+ movl bits, %ecx // bits
+ sall %cl, %eax // *((unsigned short *) in) << bits
+ addl %eax, hold // hold += (unsigned long) *((unsigned short *) in) << bits;
+ addl $2, %edx // in += 2;
+ addl $16, %ecx // bits += 16;
+ movl %edx, in
+ movl %ecx, bits
+ jmp L19
+#endif
+invalid_literal_length_code:
+ call 0f
+0: popl %eax
+ leal LC2-0b(%eax), %eax
+ movl %eax, 24(strm)
+ movl state, %esi
+ movl $27, (%esi)
+ jmp return_unused_bytes
+Linvalid_distance_code:
+ call 0f
+0: popl %eax
+ leal LC1-0b(%eax), %eax
+ movl %eax, 24(strm)
+ movl state, %eax
+ movl $27, (%eax)
+ jmp return_unused_bytes
+
+#ifdef INFLATE_STRICT
+ .align 4,0x90
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+#endif
+Lcopy_direct_from_output:
+ movl out, %edx // out
+ subl dist, %edx // from = out - dist
+ movl out, %ecx // out
+ movl len, %esi // len
+ subl $3, %esi // pre-decement len by 3
+0: // do {
+ movzbl (%edx), %eax
+ movb %al, (%ecx) // PUP(out) = PUP(from);
+ movzbl 1(%edx), %eax
+ movb %al, 1(%ecx) // PUP(out) = PUP(from);
+ movzbl 2(%edx), %eax
+ movb %al, 2(%ecx) // PUP(out) = PUP(from);
+ addl $3, %edx // from += 3
+ addl $3, %ecx // out += 3
+ subl $3, %esi // len -= 3
+ jge 0b // } while (len > 2);
+ movl %ecx, out // update out in case len == 0
+ addl $3, %esi // post-increment len by 3
+ je L_tst_do_while_loop_end // if (len) {
+ movzbl (%edx), %eax
+ movb %al, (%ecx) // PUP(out) = PUP(from);
+ incl %ecx
+ movl %ecx, out // out++
+ cmpl $2, %esi //
+ jne L_tst_do_while_loop_end // if (len>2)
+ movzbl 1(%edx), %eax
+ movb %al, (%ecx) // PUP(out) = PUP(from);
+ incl %ecx
+ movl %ecx, out // out++
+ jmp L_tst_do_while_loop_end // }
+
+ .align 4,0x90
+Lwrite_non_zero: // %edx = write, %ecx = op
+ movl window, %esi // from = window - OFF;
+ cmp %ecx, %edx // write vs op, test for wrap around window or contiguous in window
+ jae Lcontiguous_in_window // if (write >= op) branch to contiguous in window
+
+Lwrap_around_window: // wrap around window
+ addl write_wsize, %esi // from += write+wsize
+ subl %ecx, %esi // from += wsize + write - op;
+ subl %edx, %ecx // op -= write
+ cmpl %ecx, len // len vs op
+ jbe L38 // if (len <= op) break to copy from output
+ subl %ecx, len // len -= op;
+ movl out, %edx // out
+0: // do {
+ movzbl (%esi), %eax // *from
+ movb %al, (%edx) // *out
+ incl %esi // from++
+ incl %edx // out++
+ decl %ecx // --op
+ jne 0b // } while (op);
+
+ movl %edx, out // save out in case we need to break to L38
+ movl window, %esi // from = window - OFF;
+ movl len, %eax // len
+ cmpl %eax, write // write vs len
+ jae L38 // if (write >= len) break to L38
+
+ movl write, %ecx // op = write
+ subl %ecx, len // len -= op;
+0: // do {
+ movzbl (%esi), %eax // *from
+ movb %al, (%edx) // *out
+ incl %esi // from++
+ incl %edx // out++
+ decl %ecx // --op
+ jne 0b // } while (op);
+
+ movl %edx, %esi // from = out
+ movl %edx, out // save a copy of out
+ subl dist, %esi // from = out - dist;
+ jmp L38 // break to copy from output
+
+Lcontiguous_in_window: // contiguous in window, edx = write, %ecx = op
+ subl %ecx, %edx // write - op
+ addl %edx, %esi // from += write - op;
+ cmpl %ecx, len // len vs op
+ jbe L38 // if (len <= op) break to copy from output
+ movl out, %edx // out
+ subl %ecx, len // len -= op;
+
+0: // do {
+ movzbl (%esi), %eax // *from
+ movb %al, (%edx) // *out
+ incl %esi // from++
+ incl %edx // out++
+ decl %ecx // op--
+ jne 0b // } while (op);
+
+ movl %edx, out // update out
+ movl %edx, %esi // from = out
+ subl dist, %esi // from = out - dist;
+ jmp L38
+
+Linvalid_distance_too_far_back:
+ call 0f
+0: popl %eax
+ leal LC0-0b(%eax), %eax
+ movl %eax, 24(strm)
+ movl state, %ecx
+ movl $27, (%ecx)
+ jmp return_unused_bytes
+
+#endif
+
+#if (defined __x86_64__)
+ .cstring
+LC0:
+ .ascii "invalid distance too far back\0"
+LC1:
+ .ascii "invalid distance code\0"
+LC2:
+ .ascii "invalid literal/length code\0"
+ .text
+ .align 4,0x90
+
+#ifdef INFLATE_STRICT
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+#endif
+
+.globl _inflate_fast
+_inflate_fast:
+
+ // set up rbp
+ pushq %rbp
+ movq %rsp, %rbp
+
+ // save registers in stack
+ pushq %r15
+ pushq %r14
+ pushq %r13
+ pushq %r12
+ pushq %rbx
+
+ #define strm %r13
+ #define state %rdi
+ #define in %r12
+ #define in_d %r12d
+ #define out %r10
+ #define out_d %r10d
+ #define write %r15d
+ #define hold %r9
+ #define holdd %r9d
+ #define bits %r8d
+ #define lcode %r14
+ #define len %ebx
+ #define from %rcx
+ #define dmax %r11d
+
+ #define last -104(%rbp)
+ #define beg -96(%rbp)
+ #define end -88(%rbp)
+ #define wsize -80(%rbp)
+ #define whave -76(%rbp)
+ #define window -72(%rbp)
+ #define dcode -64(%rbp)
+ #define lmask -56(%rbp)
+ #define dmask -112(%rbp)
+ #define wsize_write -116(%rbp)
+ #define write_1 -128(%rbp)
+ #define dist -44(%rbp)
+
+ // reserve stack memory for local variables 128-40=88
+ subq $88, %rsp
+
+ movq %rdi, strm
+ movq 56(%rdi), state // state = (struct inflate_state FAR *)strm->state;
+ movq (strm), in // in = strm->next_in - OFF;
+ movl 8(strm), %eax // strm->avail_in
+ subl $5, %eax // (strm->avail_in - 5)
+ addq in, %rax // in + (strm->avail_in - 5)
+ movq %rax, last // last = in + (strm->avail_in - 5)
+ movq 24(strm), out // out = strm->next_out
+ movl 32(strm), %eax // strm->avail_out
+ subl %eax, %esi // (start - strm->avail_out);
+ movq out, %rdx // strm->next_out
+ subq %rsi, %rdx // out - (start - strm->avail_out);
+ movq %rdx, beg // beg = out - (start - strm->avail_out);
+ subl $257, %eax // (strm->avail_out - 257)
+ addq out, %rax // out + (strm->avail_out - 257);
+ movq %rax, end // end = out + (strm->avail_out - 257);
+
+#ifdef INFLATE_STRICT
+ movl 20(state), dmax // dmax = state->dmax;
+#endif
+
+ movl 52(state), %ecx // state->wsize
+ movl %ecx, wsize // wsize = state->wsize;
+ movl 56(state), %ebx // state->whave;
+ movl %ebx, whave // whave = state->whave;
+ movl 60(state), write // write = state->write;
+ movq 64(state), %rax // state->window
+ movq %rax, window // window = state->window;
+ movq 72(state), hold // hold = state->hold;
+ movl 80(state), bits // bits = state->bits;
+
+ movq 96(state), lcode // lcode = state->lencode;
+ movq 104(state), %rdx // state->distcode;
+ movq %rdx, dcode // dcode = state->distcode;
+
+ movl 116(state), %ecx // state->distbits
+ movl $1, %eax
+ movl %eax, %edx // 1
+ sall %cl, %edx // (1U << state->distbits)
+ movl 112(state), %ecx // state->lenbits
+ sall %cl, %eax // (1U << state->lenbits)
+ decl %eax // (1U << state->lenbits) - 1
+ movq %rax, lmask // lmask = (1U << state->lenbits) - 1
+ decl %edx // (1U << state->distbits) - 1
+ movq %rdx, dmask // dmask = (1U << state->distbits) - 1
+
+ movl wsize, %ecx // wsize
+ addl write, %ecx // wsize + write
+ movl %ecx, wsize_write // wsize_write = wsize + write
+
+ leal -1(%r15), %ebx // write - 1
+ movq %rbx, write_1 // write_1 = write - 1
+
+L_do_while_loop:
+ cmpl $14, bits // bits vs 14
+ ja 0f // if (bits < 15) {
+ movzwl (in), %eax // read 2 bytes from in
+ movl bits, %ecx // set up cl = bits
+ salq %cl, %rax // (*in) << bits
+ addq %rax, hold // hold += (*in) << bits
+ addq $2, in // in += 2
+ addl $16, bits // bits += 16
+0: // }
+ movq lmask, %rax // lmask
+ andq hold, %rax // hold & lmask
+ jmp 1f
+ .align 4,0x90
+Lop_nonzero:
+ movzbl %al, %ecx // op in al and cl
+ testb $16, %cl // check for length base processing (op&16)
+ jne L_length_base // if (op&16) branch to length base processing
+ testb $64, %cl // check for 2nd level length code (op&64==0)
+ jne L_end_of_block // if (op&64)!=0, branch for end-of-block processing
+
+ /* 2nd level length code : (op&64) == 0*/
+L_2nd_level_length_code:
+ movl $1, %eax // 1
+ sall %cl, %eax // 1 << op
+ decl %eax // ((1U << op) - 1)
+ andq hold, %rax // (hold & ((1U << op) - 1))
+ movzwl %dx, %edx
+ addq %rdx, %rax // this = lcode[this.val + (hold & ((1U << op) - 1))];
+1:
+ movl (lcode,%rax,4), %eax // this = lcode[hold & lmask];
+Ldolen:
+ movl %eax, %edx // a copy of this
+ shrl $16, %edx // edx = this.val;
+ movzbl %ah, %ecx // op = this.bits
+ shrq %cl, hold // hold >>= op;
+ subl %ecx, bits // bits -= op;
+ testb %al, %al // op = (unsigned)(this.op);
+ jne Lop_nonzero // if (op!-0) branch for copy operation
+L_literal:
+ movb %dl, (out) // *out = this.val
+ incq out // out ++
+L_do_while_loop_check:
+ cmpq last, in // in vs last
+ jae L_return_unused_byte // if in >= last, break to return unused byte processing
+ cmpq end, out // out vs end
+ jb L_do_while_loop // back to do_while_loop if out < end
+
+ /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
+
+L_return_unused_byte:
+ movl out_d, %esi
+ jmp L34
+
+L_length_base: /* al = cl = op, edx = this.val, op&16 = 16 */
+ movzwl %dx, len // len = (unsigned)(this.val);
+ movl %ecx, %edx // op
+ andl $15, %edx // op &= 15;
+ je 1f // if (op) {
+ cmpl bits, %edx // op vs bits
+ jbe 0f // if (bits < op) {
+ movzbl (in), %eax // *in
+ movl bits, %ecx // cl = bits
+ salq %cl, %rax // *in << bits
+ addq %rax, hold // hold += (unsigned long)(PUP(in)) << bits;
+ incq in // in++
+ addl $8, bits // bits += 8
+0: // }
+ movl $1, %eax // 1
+ movl %edx, %ecx // cl = op
+ sall %cl, %eax // 1 << op
+ decl %eax // (1 << op) - 1
+ andl holdd, %eax // (unsigned)hold & ((1U << op) - 1);
+ addl %eax, len // len += (unsigned)hold & ((1U << op) - 1);
+ shrq %cl, hold // hold >>= op;
+ subl %edx, bits // bits -= op;
+1: // }
+ cmpl $14, bits // bits vs 14
+ jbe L99 // if (bits < 15) go to loading to hold and return to L19
+L19: // }
+ movq dmask, %rax // dmask
+ andq hold, %rax // hold & dmask
+ movq dcode, %rdx // dcode[]
+ movl (%rdx,%rax,4), %eax // this = dcode[hold & dmask];
+ jmp L_dodist
+ .align 4,0x90
+0: // op&16 == 0, test (op&64)==0 for 2nd level distance code
+ testb $64, %cl // op&64
+ jne L_invalid_distance_code // if ((op&64)==0) { /* 2nd level distance code */
+ movl $1, %eax // 1
+ sall %cl, %eax // 1 << op
+ decl %eax // (1 << op) - 1
+ andq hold, %rax // (hold & ((1U << op) - 1))
+ movzwl %dx, %edx // this.val
+ addq %rdx, %rax // this.val + (hold & ((1U << op) - 1))
+ movq dcode, %rcx // dcode[]
+ movl (%rcx,%rax,4), %eax // this = dcode[this.val + (hold & ((1U << op) - 1))];
+L_dodist:
+ movl %eax, %edx // this
+ shrl $16, %edx // dist = (unsigned)(this.val);
+ movzbl %ah, %ecx // cl = op = this.bits
+ shrq %cl, hold // hold >>= op;
+ subl %ecx, bits // bits -= op;
+ movzbl %al, %ecx // op = (unsigned)(this.op);
+ testb $16, %cl // (op & 16) test for distance base
+ je 0b // if (op&16) == 0, branch to check for 2nd level distance code
+
+L_distance_base: /* distance base */
+
+ movl %ecx, %esi // op
+ andl $15, %esi // op&=15
+ cmpl bits, %esi // op vs bits
+ jbe 1f // if (bits < op) {
+ movzbl (in), %eax // *in
+ movl bits, %ecx // cl = bits
+ salq %cl, %rax // *in << bits
+ addq %rax, hold // hold += (unsigned long)(PUP(in)) << bits;
+ incq in // in++
+ addl $8, bits // bits += 8
+ cmpl bits, %esi // op vs bits
+ jbe 1f // if (bits < op) {
+ movzbl (in), %eax // *in
+ movl bits, %ecx // cl = bits
+ salq %cl, %rax // *in << bits
+ addq %rax, hold // hold += (unsigned long)(PUP(in)) << bits;
+ incq in // in++
+ addl $8, bits // bits += 8
+1: // } }
+
+ movzwl %dx, %edx // dist
+ movl $1, %eax // 1
+ movl %esi, %ecx // cl = op
+ sall %cl, %eax // (1 << op)
+ decl %eax // (1 << op) - 1
+ andl holdd, %eax // (unsigned)hold & ((1U << op) - 1)
+ addl %edx, %eax // dist += (unsigned)hold & ((1U << op) - 1);
+ movl %eax, dist // save a copy of dist in stack
+
+#ifdef INFLATE_STRICT
+ cmp %eax, dmax // dmax vs dist
+ jb L_invalid_distance_too_far_back // if (dmax < dist) break for invalid distance too far back
+#endif
+
+ shrq %cl, hold // hold >>= op;
+ subl %esi, bits // bits -= op;
+ movl out_d, %esi // out
+ movl out_d, %eax // out
+ subl beg, %eax // op = out - beg
+ cmpl %eax, dist // dist vs op, /* see if copy from window */
+ jbe L_copy_direct_from_output // if (dist <= op) branch to copy direct from output
+
+L_distance_back_in_window:
+
+ movl dist, %edx // dist
+ subl %eax, %edx // op = dist - op; /* distance back in window */
+
+ cmpl %edx, whave // whave vs op
+ jb L_invalid_distance_too_far_back // if (op > whave), break for invalid distance too far back
+
+ testl write, write // if (write!=0)
+ jne L_wrap_around_window // branch to wrap around window
+
+L_very_common_case:
+
+ movl wsize, %eax // wsize
+ subl %edx, %eax // wsize - op
+ movq window, from // from = window - OFF;
+ addq %rax, from // from += wsize - op;
+
+ movl %edx, %esi // op
+ cmpl %edx, len // len vs op
+ ja L_some_from_window // if (len > op), branch for aligned code block L_some_from_window
+L38:
+ subl $3, len // pre-decrement len by 3
+ jge 0f // if len >= 3, branch to the aligned code block
+1: addl $3, len // post-increment len by 3
+ je L_do_while_loop_check // if (len==0) break to L_do_while_loop_check
+ movzbl (from), %eax // *from
+ movb %al, (out) // *out
+ incq out // out++
+ cmpl $2, len // len vs 2
+ jne L_do_while_loop_check // if len!=2 break to L_do_while_loop_check
+ movzbl 1(from), %eax // *from
+ movb %al, (out) // *out
+ incq out // out++
+ jmp L_do_while_loop_check // break to L_do_while_loop_check
+
+ .align 4,0x90
+0: // do {
+ movzbl (from), %eax // *from
+ movb %al, (out) // *out
+ movzbl 1(from), %eax // *from
+ movb %al, 1(out) // *out
+ movzbl 2(from), %eax // *from
+ movb %al, 2(out) // *out
+ addq $3, out // out += 3
+ addq $3, from // from += 3
+ subl $3, len // len -= 3
+ jge 0b // } while (len>=0);
+ jmp 1b // branch back to the possibly unaligned code
+
+ .align 4,0x90
+L_end_of_block:
+ andl $32, %ecx // op & 32
+ jne L101 // if (op&32) branch to end-of-block break
+ leaq LC2(%rip), from
+ movq from, 48(strm) // state->mode
+ movl $27, (state) // state->mode = BAD;
+ movl out_d, %esi
+
+L34:
+ movl bits, %eax // bits
+ shrl $3, %eax // len = bits >> 3;
+ mov %eax, %edx // len
+ subq %rdx, in // in -= len
+ sall $3, %eax // len << 3
+ movl bits, %ecx // bits
+ subl %eax, %ecx // bits -= len << 3
+ movq in, (strm) // strm->next_in = in + OFF;
+ movq out, 24(strm) // strm->next_out = out + OFF;
+ cmpq in, last // last vs in
+ jbe L67 // if (last <= in) branch to L67 and return to L69
+ movl last, %eax // last
+ addl $5, %eax // last + 5
+ subl in_d, %eax // 5 + last - in
+L69:
+ movl %eax, 8(strm) // update strm->avail_in
+
+ cmpq end, out // out vs end
+ jae L70 // if out<=end branch to L70 and return to L72
+ movl end, %eax // end
+ addl $257, %eax // 257 + end
+ subl %esi, %eax // 257 + end - out;
+L72:
+ movl %eax, 32(strm) // update strm->avail_out
+
+ movl $1, %eax // 1
+ sall %cl, %eax // 1 << bits
+ decl %eax // (1U << bits) - 1
+ andq hold, %rax // hold &= (1U << bits) - 1;
+ movq %rax, 72(state) // state->hold = hold;
+ movl %ecx, 80(state) // state->bits = bits;
+
+ // clear stack memory for local variables
+ addq $88, %rsp
+
+ // restore registers from stack
+ popq %rbx
+ popq %r12
+ popq %r13
+ popq %r14
+ popq %r15
+
+ // return to caller
+ leave
+ ret
+
+ .align 4,0x90
+L99:
+ leal 8(bits), %esi // esi = bits+8
+ movzbl (in), %edx // 1st *in
+ movl bits, %ecx // cl = bits
+ salq %cl, %rdx // 1st *in << 8
+ addq %rdx, hold // 1st hold += (unsigned long)(PUP(in)) << bits;
+ movzbl 1(in), %eax // 2nd *in
+ movl %esi, %ecx // cl = bits + 8
+ salq %cl, %rax // 2nd *in << bits+8
+ addq %rax, hold // 2nd hold += (unsigned long)(PUP(in)) << bits;
+ addq $2, in // in += 2
+ addl $16, bits // bits += 16
+ jmp L19
+
+L101:
+ movl $11, (state)
+ movl out_d, %esi
+ jmp L34
+ .align 4,0x90
+L70:
+ movl end, %eax // end
+ subl %esi, %eax // end - out
+ addl $257, %eax // 257 + end - out
+ jmp L72
+ .align 4,0x90
+L67:
+ movl last, %eax // last
+ subl in_d, %eax // last - in
+ addl $5, %eax // 5 + last - in
+ jmp L69
+
+
+ .align 4,0x90
+
+ // stuffing the following 4 bytes to align the major loop to a 16-byte boundary to give the better performance
+ .byte 0
+ .byte 0
+ .byte 0
+ .byte 0
+L_copy_direct_from_output:
+ mov dist, %eax // dist
+ movq out, %rdx // out
+ subq %rax, %rdx // from = out - dist;
+ subl $3, len // pre-decrement len by 3
+ // do {
+0: movzbl (%rdx), %eax // *from
+ movb %al, (out) // *out
+ movzbl 1(%rdx), %eax // *from
+ movb %al, 1(out) // *out
+ movzbl 2(%rdx), %eax // *from
+ movb %al, 2(out) // *out
+ addq $3, out // out+=3
+ addq $3, %rdx // from+=3
+ subl $3, len // len-=3
+ jge 0b // } while (len>=0);
+1: addl $3, len // post-increment len by 3
+ je L_do_while_loop_check // if len==0, branch to do_while_loop_check
+
+ movzbl (%rdx), %eax // *from
+ movb %al, (out) // *out
+ incq out // out++
+ cmpl $2, len // len == 2 ?
+ jne L_do_while_loop_check // if len==1, branch to do_while_loop_check
+
+ movzbl 1(%rdx), %eax // *from
+ movb %al, (out) // *out
+ incq out // out++
+ jmp L_do_while_loop_check // branch to do_while_loop_check
+
+ .align 4,0x90
+L_some_from_window: // from : from, out, %esi/%edx = op
+ // do {
+ movzbl (from), %eax // *from
+ movb %al, (out) // *out
+ incq from // from++
+ incq out // out++
+ decl %esi // --op
+ jne L_some_from_window // } while (op);
+ subl %edx, len // len -= op;
+ mov dist, %eax // dist
+ movq out, from // out
+ subq %rax, from // from = out - dist;
+ jmp L38 // copy from output
+
+ .align 4,0x90
+L_wrap_around_window:
+ cmpl %edx, write // write vs op
+ jae L_contiguous_in_window // if (write >= op) branch to contiguous in window
+ movl wsize_write, %eax // wsize+write
+ subl %edx, %eax // wsize+write-op
+ movq window, from // from = window - OFF
+ addq %rax, from // from += wsize+write-op
+ subl write, %edx // op -= write
+ cmpl %edx, len // len vs op
+ jbe L38 // if (len<=op) branch to copy from output
+
+ subl %edx, len // len -= op;
+0: // do {
+ movzbl (from), %eax // *from
+ movb %al, (out) // *out
+ incq from // from++
+ incq out // out++
+ decl %edx // op--
+ jne 0b // } while (op);
+ movq window, from
+
+ cmpl len, write // write vs len
+ jae L38 // if (write >= len) branch to copy from output
+ movl write, %esi // op = write
+ subl write, len // len -= op
+1: // do {
+ movzbl (from), %eax // *from
+ movb %al, (out) // *out
+ incq from // from++
+ incq out // out++
+ decl %esi // op--
+ jne 1b // } while (op);
+ mov dist, %eax // dist
+ movq out, from // out
+ subq %rax, from // from = out - dist;
+ jmp L38
+
+ .align 4,0x90
+L_contiguous_in_window:
+ movl write, %eax // write
+ subl %edx, %eax // write - op
+ movq window, from // from = window - OFF
+ addq %rax, from // from += write - op
+ cmpl %edx, len // len vs op
+ jbe L38 // if (len <= op) branch to copy from output
+ subl %edx, len // len -= op;
+2: // do {
+ movzbl (from), %eax // *from
+ movb %al, (out) // *out
+ incq from // from++
+ incq out // out++
+ decl %edx // op--
+ jne 2b // } while (op);
+
+ mov dist, %eax // dist
+ movq out, from // out
+ subq %rax, from // from = out - dist;
+ jmp L38 // copy from output
+
+ .align 4,0x90
+L_invalid_distance_code:
+ leaq LC1(%rip), %rdx
+ movq %rdx, 48(strm)
+ movl $27, (state)
+ movl out_d, %esi
+ jmp L34
+
+L_invalid_distance_too_far_back:
+ leaq LC0(%rip), %rbx
+ movq %rbx, 48(strm) // error message
+ movl $27, (state) // state->mode = BAD
+ jmp L34
+
+#endif
projects / apple / xnu.git / blobdiff