/* lzo_asm.h -- LZO assembler stuff

   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/
 */


/***********************************************************************
// <asmconfig.h>
************************************************************************/

#if !defined(__i386__)
#  error
#endif

#if !defined(IN_CONFIGURE)
#if defined(LZO_HAVE_CONFIG_H)
#  include <config.h>
#else
   /* manual configuration - see defaults below */
#  if defined(__ELF__)
#    define MFX_ASM_HAVE_TYPE 1
#    define MFX_ASM_NAME_NO_UNDERSCORES 1
#  elif defined(__linux__)              /* Linux a.out */
#    define MFX_ASM_ALIGN_PTWO 1
#  elif defined(__DJGPP__)
#    define MFX_ASM_ALIGN_PTWO 1
#  elif defined(__GO32__)               /* djgpp v1 */
#    define MFX_ASM_CANNOT_USE_EBP 1
#  elif defined(__EMX__)
#    define MFX_ASM_ALIGN_PTWO 1
#    define MFX_ASM_CANNOT_USE_EBP 1
#  endif
#endif
#endif

#if 1 && defined(__ELF__)
.section .note.GNU-stack,"",@progbits
#endif
#if 0 && defined(__ELF__)
#undef i386
.arch i386
.code32
#endif


/***********************************************************************
// name always uses underscores
// [ OLD: name (default: with underscores) ]
************************************************************************/

#if !defined(LZO_ASM_NAME)
#  define LZO_ASM_NAME(n)       _ ## n
#if 0
#  if defined(MFX_ASM_NAME_NO_UNDERSCORES)
#    define LZO_ASM_NAME(n)     n
#  else
#    define LZO_ASM_NAME(n)     _ ## n
#  endif
#endif
#endif


/***********************************************************************
// .type (default: do not use)
************************************************************************/

#if !defined(LZO_PUBLIC)
#if defined(__LZO_DB__)
#  define LZO_PUBLIC(func) \
        .p2align 4 ; .byte 0,0,0,0,0,0,0 ; .ascii "LZO_START"
#  define LZO_PUBLIC_END(func) \
        .p2align 4,0x90 ; .ascii "LZO_END"
#elif defined(MFX_ASM_HAVE_TYPE)
#  define LZO_PUBLIC(func) \
        ALIGN3 ; .type LZO_ASM_NAME(func),@function ; \
        .globl LZO_ASM_NAME(func) ; LZO_ASM_NAME(func):
#  define LZO_PUBLIC_END(func) \
        .size LZO_ASM_NAME(func),.-LZO_ASM_NAME(func)
#else
#  define LZO_PUBLIC(func) \
        ALIGN3 ; .globl LZO_ASM_NAME(func) ; LZO_ASM_NAME(func):
#  define LZO_PUBLIC_END(func)
#endif
#endif


/***********************************************************************
// .align (default: bytes)
************************************************************************/

#if !defined(MFX_ASM_ALIGN_BYTES) && !defined(MFX_ASM_ALIGN_PTWO)
#  define MFX_ASM_ALIGN_BYTES 1
#endif

#if !defined(LZO_ASM_ALIGN)
#  if defined(MFX_ASM_ALIGN_PTWO)
#    define LZO_ASM_ALIGN(x)    .align x
#  else
#    define LZO_ASM_ALIGN(x)    .align (1 << (x))
#  endif
#endif

#define ALIGN1              LZO_ASM_ALIGN(1)
#define ALIGN2              LZO_ASM_ALIGN(2)
#define ALIGN3              LZO_ASM_ALIGN(3)


/***********************************************************************
// ebp usage (default: can use)
************************************************************************/

#if !defined(MFX_ASM_CANNOT_USE_EBP)
#  if 1 && !defined(N_3_EBP) && !defined(N_255_EBP)
#    define N_3_EBP 1
#  endif
#  if 0 && !defined(N_3_EBP) && !defined(N_255_EBP)
#    define N_255_EBP 1
#  endif
#endif

#if defined(N_3_EBP) && defined(N_255_EBP)
#  error
#endif
#if defined(MFX_ASM_CANNOT_USE_EBP)
#  if defined(N_3_EBP) || defined(N_255_EBP)
#    error
#  endif
#endif

#if !defined(N_3)
#  if defined(N_3_EBP)
#    define N_3         %ebp
#  else
#    define N_3         $3
#  endif
#endif

#if !defined(N_255)
#  if defined(N_255_EBP)
#    define N_255       %ebp
#    define NOTL_3(r)   xorl %ebp,r
#  else
#    define N_255       $255
#  endif
#endif

#if !defined(NOTL_3)
#  define NOTL_3(r)     xorl N_3,r
#endif


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

#ifndef INP
#define INP      4+36(%esp)
#define INS      8+36(%esp)
#define OUTP    12+36(%esp)
#define OUTS    16+36(%esp)
#endif

#define INEND         4(%esp)
#define OUTEND        (%esp)


#if defined(LZO_TEST_DECOMPRESS_OVERRUN_INPUT)
#  define TEST_IP_R(r)      cmpl r,INEND ; jb .L_input_overrun
#  define TEST_IP(addr,r)   leal addr,r ; TEST_IP_R(r)
#else
#  define TEST_IP_R(r)
#  define TEST_IP(addr,r)
#endif

#if defined(LZO_TEST_DECOMPRESS_OVERRUN_OUTPUT)
#  define TEST_OP_R(r)      cmpl r,OUTEND ; jb .L_output_overrun
#  define TEST_OP(addr,r)   leal addr,r ; TEST_OP_R(r)
#else
#  define TEST_OP_R(r)
#  define TEST_OP(addr,r)
#endif

#if defined(LZO_TEST_DECOMPRESS_OVERRUN_LOOKBEHIND)
#  define TEST_LOOKBEHIND(r)    cmpl OUTP,r ; jb .L_lookbehind_overrun
#else
#  define TEST_LOOKBEHIND(r)
#endif


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

#define LODSB           movb (%esi),%al ; incl %esi

#define MOVSB(r1,r2,x)  movb (r1),x ; incl r1 ; movb x,(r2) ; incl r2
#define MOVSW(r1,r2,x)  movb (r1),x ; movb x,(r2) ; \
                        movb 1(r1),x ; addl $2,r1 ; \
                        movb x,1(r2) ; addl $2,r2
#define MOVSL(r1,r2,x)  movl (r1),x ; addl $4,r1 ; movl x,(r2) ; addl $4,r2

#if defined(LZO_DEBUG)
#define COPYB_C(r1,r2,x,rc) \
                        cmpl $0,rc ; jz .L_assert_fail; \
                        9: MOVSB(r1,r2,x) ; decl rc ; jnz 9b
#define COPYL_C(r1,r2,x,rc) \
                        cmpl $0,rc ; jz .L_assert_fail; \
                        9: MOVSL(r1,r2,x) ; decl rc ; jnz 9b
#else
#define COPYB_C(r1,r2,x,rc) \
                        9: MOVSB(r1,r2,x) ; decl rc ; jnz 9b
#define COPYL_C(r1,r2,x,rc) \
                        9: MOVSL(r1,r2,x) ; decl rc ; jnz 9b
#endif

#define COPYB(r1,r2,x)  COPYB_C(r1,r2,x,%ecx)
#define COPYL(r1,r2,x)  COPYL_C(r1,r2,x,%ecx)


/***********************************************************************
// not used
************************************************************************/

#if 0

#if 0
#define REP_MOVSB(x)    rep ; movsb
#define REP_MOVSL(x)    shrl $2,%ecx ; rep ; movsl
#elif 1
#define REP_MOVSB(x)    COPYB(%esi,%edi,x)
#define REP_MOVSL(x)    shrl $2,%ecx ; COPYL(%esi,%edi,x)
#else
#define REP_MOVSB(x)    rep ; movsb
#define REP_MOVSL(x)    jmp 9f ; 8: movsb ; decl %ecx ; \
                        9: testl $3,%edi ; jnz 8b ; \
                        movl %ecx,x ; shrl $2,%ecx ; andl $3,x ; \
                        rep ; movsl ; movl x,%ecx ; rep ; movsb
#endif

#if 1
#define NEGL(x)         negl x
#else
#define NEGL(x)         xorl $-1,x ; incl x
#endif

#endif


/*
vi:ts=4
*/