/* lzo1x_d.ash -- assembler implementation of the LZO1X decompression algorithm

   This file is part of the LZO real-time data compression library.

   Copyright (C) 1996-2014 Markus Franz Xaver Johannes Oberhumer

   All Rights Reserved.

   The LZO library is free software; you can redistribute it and/or

   modify it under the terms of the GNU General Public License as

   published by the Free Software Foundation; either version 2 of

   the License, or (at your option) any later version.

   The LZO library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with the LZO library; see the file COPYING.

   If not, write to the Free Software Foundation, Inc.,

   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

   Markus F.X.J. Oberhumer

   <markus@oberhumer.com>

   http://www.oberhumer.com/opensource/lzo/

 */

#if !defined(LZO1X) && !defined(LZO1Y)

#  define LZO1X

#endif

#if defined(LZO_FAST)

#  define NN    3

#else

#  define NN    0

#endif

/***********************************************************************

// init

************************************************************************/

        xorl    %eax,%eax

        xorl    %ebx,%ebx       /* high bits 9-32 stay 0 */

        lodsb

        cmpb    $17,%al

        jbe     .L01

        subb    $17-NN,%al

#if defined(LZO_FAST)

        jmp     .LFLR

#else

        cmpb    $4,%al

        jae     .LFLR

#if 1

        TEST_OP((%edi,%eax),%edx)

        TEST_IP((%esi,%eax),%edx)

        movl    %eax,%ecx

        jmp     .LFLR2

#else

        jmp     .LFLR3

#endif

#endif

/***********************************************************************

// literal run

************************************************************************/

0:      addl    N_255,%eax

        TEST_IP(18(%esi,%eax),%edx)     /* minimum */

1:      movb    (%esi),%bl

        incl    %esi

        orb     %bl,%bl

        jz      0b

        leal    18+NN(%eax,%ebx),%eax

        jmp     3f

        ALIGN3

.L00:

#ifdef LZO_DEBUG

    andl $0xffffff00,%eax ; jnz .L_assert_fail

    andl $0xffffff00,%ebx ; jnz .L_assert_fail

    xorl %eax,%eax ; xorl %ebx,%ebx

    xorl %ecx,%ecx ; xorl %edx,%edx

#endif

        TEST_IP_R(%esi)

        LODSB

.L01:

        cmpb    $16,%al

        jae     .LMATCH

/* a literal run */

        orb     %al,%al

        jz      1b

        addl    $3+NN,%eax

3:

.LFLR:

        TEST_OP(-NN(%edi,%eax),%edx)

        TEST_IP(-NN(%esi,%eax),%edx)

#if defined(LZO_FAST)

        movl    %eax,%ecx

        NOTL_3(%eax)

        shrl    $2,%ecx

        andl    N_3,%eax

        COPYL(%esi,%edi,%edx)

        subl    %eax,%esi

        subl    %eax,%edi

#else

        movl    %eax,%ecx

        shrl    $2,%eax

        andl    N_3,%ecx

        COPYL_C(%esi,%edi,%edx,%eax)

.LFLR2:

        rep

        movsb

#endif

#ifdef LZO_DEBUG

    andl $0xffffff00,%eax ; jnz .L_assert_fail

    andl $0xffffff00,%ebx ; jnz .L_assert_fail

    xorl %eax,%eax ; xorl %ebx,%ebx

    xorl %ecx,%ecx ; xorl %edx,%edx

#endif

        LODSB

        cmpb    $16,%al

        jae     .LMATCH

/***********************************************************************

// R1

************************************************************************/

        TEST_OP(3(%edi),%edx)

        shrl    $2,%eax

        movb    (%esi),%bl

#if defined(LZO1X)

        leal    -0x801(%edi),%edx

#elif defined(LZO1Y)

        leal    -0x401(%edi),%edx

#endif

        leal    (%eax,%ebx,4),%eax

        incl    %esi

        subl    %eax,%edx

        TEST_LOOKBEHIND(%edx)

#if defined(LZO_FAST)

        movl    (%edx),%ecx

        movl    %ecx,(%edi)

#else

        movb    (%edx),%al

        movb    %al,(%edi)

        movb    1(%edx),%al

        movb    %al,1(%edi)

        movb    2(%edx),%al

        movb    %al,2(%edi)

#endif

        addl    N_3,%edi

        jmp     .LMDONE

/***********************************************************************

// M2

************************************************************************/

        ALIGN3

.LMATCH:

        cmpb    $64,%al

        jb      .LM3MATCH

/* a M2 match */

        movl    %eax,%ecx

        shrl    $2,%eax

        leal    -1(%edi),%edx

#if defined(LZO1X)

        andl    $7,%eax

        movb    (%esi),%bl

        shrl    $5,%ecx

        leal    (%eax,%ebx,8),%eax

#elif defined(LZO1Y)

        andl    N_3,%eax

        movb    (%esi),%bl

        shrl    $4,%ecx

        leal    (%eax,%ebx,4),%eax

#endif

        incl    %esi

        subl    %eax,%edx

#if defined(LZO_FAST)

#if defined(LZO1X)

        addl    $1+3,%ecx

#elif defined(LZO1Y)

        addl    $2,%ecx

#endif

#else

#if defined(LZO1X)

        incl    %ecx

#elif defined(LZO1Y)

        decl    %ecx

#endif

#endif

        cmpl    N_3,%eax

        jae     .LCOPYLONG

        jmp     .LCOPYBYTE

/***********************************************************************

// M3

************************************************************************/

0:      addl    N_255,%eax

        TEST_IP(3(%esi),%edx)       /* minimum */

1:      movb    (%esi),%bl

        incl    %esi

        orb     %bl,%bl

        jz      0b

        leal    33+NN(%eax,%ebx),%ecx

        xorl    %eax,%eax

        jmp     3f

        ALIGN3

.LM3MATCH:

        cmpb    $32,%al

        jb      .LM4MATCH

/* a M3 match */

        andl    $31,%eax

        jz      1b

        lea     2+NN(%eax),%ecx

3:

#ifdef LZO_DEBUG

    andl $0xffff0000,%eax ; jnz .L_assert_fail

#endif

        movw    (%esi),%ax

        leal    -1(%edi),%edx

        shrl    $2,%eax

        addl    $2,%esi

        subl    %eax,%edx

        cmpl    N_3,%eax

        jb      .LCOPYBYTE

/***********************************************************************

// copy match

************************************************************************/

        ALIGN1

.LCOPYLONG:                      /* copy match using longwords */

        TEST_LOOKBEHIND(%edx)

#if defined(LZO_FAST)

        leal    -3(%edi,%ecx),%eax

        shrl    $2,%ecx

        TEST_OP_R(%eax)

        COPYL(%edx,%edi,%ebx)

        movl    %eax,%edi

        xorl    %ebx,%ebx

#else

        TEST_OP((%edi,%ecx),%eax)

        movl    %ecx,%ebx

        shrl    $2,%ebx

        jz      2f

        COPYL_C(%edx,%edi,%eax,%ebx)

        andl    N_3,%ecx

        jz      1f

2:      COPYB_C(%edx,%edi,%al,%ecx)

1:

#endif

.LMDONE:

        movb    -2(%esi),%al

        andl    N_3,%eax

        jz      .L00

.LFLR3:

        TEST_OP((%edi,%eax),%edx)

        TEST_IP((%esi,%eax),%edx)

#if defined(LZO_FAST)

        movl    (%esi),%edx

        addl    %eax,%esi

        movl    %edx,(%edi)

        addl    %eax,%edi

#else

        COPYB_C(%esi,%edi,%cl,%eax)

#endif

#ifdef LZO_DEBUG

    andl $0xffffff00,%eax ; jnz .L_assert_fail

    andl $0xffffff00,%ebx ; jnz .L_assert_fail

    xorl %eax,%eax ; xorl %ebx,%ebx

    xorl %ecx,%ecx ; xorl %edx,%edx

#endif

        LODSB

        jmp     .LMATCH

        ALIGN3

.LCOPYBYTE:                      /* copy match using bytes */

        TEST_LOOKBEHIND(%edx)

        TEST_OP(-NN(%edi,%ecx),%eax)

        xchgl   %edx,%esi

#if defined(LZO_FAST)

        subl    N_3,%ecx

#endif

        rep

        movsb

        movl    %edx,%esi

        jmp     .LMDONE

/***********************************************************************

// M4

************************************************************************/

0:      addl    N_255,%ecx

        TEST_IP(3(%esi),%edx)       /* minimum */

1:      movb    (%esi),%bl

        incl    %esi

        orb     %bl,%bl

        jz      0b

        leal    9+NN(%ebx,%ecx),%ecx

        jmp     3f

        ALIGN3

.LM4MATCH:

        cmpb    $16,%al

        jb      .LM1MATCH

/* a M4 match */

        movl    %eax,%ecx

        andl    $8,%eax

        shll    $13,%eax        /* save in bit 16 */

        andl    $7,%ecx

        jz      1b

        addl    $2+NN,%ecx

3:

#ifdef LZO_DEBUG

    movl %eax,%edx ; andl $0xfffe0000,%edx ; jnz .L_assert_fail

#endif

        movw    (%esi),%ax

        addl    $2,%esi

        leal    -0x4000(%edi),%edx

        shrl    $2,%eax

        jz      .LEOF

        subl    %eax,%edx

        jmp     .LCOPYLONG

/***********************************************************************

// M1

************************************************************************/

        ALIGN3

.LM1MATCH:

/* a M1 match */

        TEST_OP(2(%edi),%edx)

        shrl    $2,%eax

        movb    (%esi),%bl

        leal    -1(%edi),%edx

        leal    (%eax,%ebx,4),%eax

        incl    %esi

        subl    %eax,%edx

        TEST_LOOKBEHIND(%edx)

        movb    (%edx),%al      /* we must use this because edx can be edi-1 */

        movb    %al,(%edi)

        movb    1(%edx),%bl

        movb    %bl,1(%edi)

        addl    $2,%edi

        jmp     .LMDONE

/***********************************************************************

//

************************************************************************/

.LEOF:

/****   xorl    %eax,%eax          eax=0 from above */

        cmpl    $3+NN,%ecx      /* ecx must be 3/6 */

        setnz   %al

/*

vi:ts=4

*/