prim_asm.h

u-boot1.3.0的原码,从配了网络驱动和FLASH的驱动,并该用ESC竟如

/****************************************************************************
*
*                       Realmode X86 Emulator Library
*
*               Copyright (C) 1991-2004 SciTech Software, Inc.
*                    Copyright (C) David Mosberger-Tang
*                      Copyright (C) 1999 Egbert Eich
*
*  ========================================================================
*
*  Permission to use, copy, modify, distribute, and sell this software and
*  its documentation for any purpose is hereby granted without fee,
*  provided that the above copyright notice appear in all copies and that
*  both that copyright notice and this permission notice appear in
*  supporting documentation, and that the name of the authors not be used
*  in advertising or publicity pertaining to distribution of the software
*  without specific, written prior permission.  The authors makes no
*  representations about the suitability of this software for any purpose.
*  It is provided "as is" without express or implied warranty.
*
*  THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
*  INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
*  EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
*  CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
*  USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
*  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
*  PERFORMANCE OF THIS SOFTWARE.
*
*  ========================================================================
*
* Language:     Watcom C++ 10.6 or later
* Environment:  Any
* Developer:    Kendall Bennett
*
* Description:  Inline assembler versions of the primitive operand
*               functions for faster performance. At the moment this is
*               x86 inline assembler, but these functions could be replaced
*               with native inline assembler for each supported processor
*               platform.
*
****************************************************************************/

#ifndef __X86EMU_PRIM_ASM_H
#define __X86EMU_PRIM_ASM_H

#ifdef  __WATCOMC__

#ifndef VALIDATE
#define __HAVE_INLINE_ASSEMBLER__
#endif

u32 get_flags_asm(void);
#pragma aux get_flags_asm =         \
    "pushf"                         \
    "pop    eax"                    \
    value [eax]                     \
    modify exact [eax];

u16 aaa_word_asm(u32 * flags, u16 d);
#pragma aux aaa_word_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "aaa"                           \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [ax]                 \
    value [ax]                      \
    modify exact [ax];

u16 aas_word_asm(u32 * flags, u16 d);
#pragma aux aas_word_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "aas"                           \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [ax]                 \
    value [ax]                      \
    modify exact [ax];

u16 aad_word_asm(u32 * flags, u16 d);
#pragma aux aad_word_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "aad"                           \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [ax]                 \
    value [ax]                      \
    modify exact [ax];

u16 aam_word_asm(u32 * flags, u8 d);
#pragma aux aam_word_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "aam"                           \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [al]                 \
    value [ax]                      \
    modify exact [ax];

u8 adc_byte_asm(u32 * flags, u8 d, u8 s);
#pragma aux adc_byte_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "adc    al,bl"                  \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [al] [bl]            \
    value [al]                      \
    modify exact [al bl];

u16 adc_word_asm(u32 * flags, u16 d, u16 s);
#pragma aux adc_word_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "adc    ax,bx"                  \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [ax] [bx]            \
    value [ax]                      \
    modify exact [ax bx];

u32 adc_long_asm(u32 * flags, u32 d, u32 s);
#pragma aux adc_long_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "adc    eax,ebx"                \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [eax] [ebx]          \
    value [eax]                     \
    modify exact [eax ebx];

u8 add_byte_asm(u32 * flags, u8 d, u8 s);
#pragma aux add_byte_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "add    al,bl"                  \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [al] [bl]            \
    value [al]                      \
    modify exact [al bl];

u16 add_word_asm(u32 * flags, u16 d, u16 s);
#pragma aux add_word_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "add    ax,bx"                  \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [ax] [bx]            \
    value [ax]                      \
    modify exact [ax bx];

u32 add_long_asm(u32 * flags, u32 d, u32 s);
#pragma aux add_long_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "add    eax,ebx"                \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [eax] [ebx]          \
    value [eax]                     \
    modify exact [eax ebx];

u8 and_byte_asm(u32 * flags, u8 d, u8 s);
#pragma aux and_byte_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "and    al,bl"                  \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [al] [bl]            \
    value [al]                      \
    modify exact [al bl];

u16 and_word_asm(u32 * flags, u16 d, u16 s);
#pragma aux and_word_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "and    ax,bx"                  \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [ax] [bx]            \
    value [ax]                      \
    modify exact [ax bx];

u32 and_long_asm(u32 * flags, u32 d, u32 s);
#pragma aux and_long_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "and    eax,ebx"                \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [eax] [ebx]          \
    value [eax]                     \
    modify exact [eax ebx];

u8 cmp_byte_asm(u32 * flags, u8 d, u8 s);
#pragma aux cmp_byte_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "cmp    al,bl"                  \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [al] [bl]            \
    value [al]                      \
    modify exact [al bl];

u16 cmp_word_asm(u32 * flags, u16 d, u16 s);
#pragma aux cmp_word_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "cmp    ax,bx"                  \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [ax] [bx]            \
    value [ax]                      \
    modify exact [ax bx];

u32 cmp_long_asm(u32 * flags, u32 d, u32 s);
#pragma aux cmp_long_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "cmp    eax,ebx"                \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [eax] [ebx]          \
    value [eax]                     \
    modify exact [eax ebx];

u8 daa_byte_asm(u32 * flags, u8 d);
#pragma aux daa_byte_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "daa"                           \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [al]                 \
    value [al]                      \
    modify exact [al];

u8 das_byte_asm(u32 * flags, u8 d);
#pragma aux das_byte_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "das"                           \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [al]                 \
    value [al]                      \
    modify exact [al];

u8 dec_byte_asm(u32 * flags, u8 d);
#pragma aux dec_byte_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "dec    al"                     \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [al]                 \
    value [al]                      \
    modify exact [al];

u16 dec_word_asm(u32 * flags, u16 d);
#pragma aux dec_word_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "dec    ax"                     \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [ax]                 \
    value [ax]                      \
    modify exact [ax];

u32 dec_long_asm(u32 * flags, u32 d);
#pragma aux dec_long_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "dec    eax"                    \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [eax]                \
    value [eax]                     \
    modify exact [eax];

u8 inc_byte_asm(u32 * flags, u8 d);
#pragma aux inc_byte_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "inc    al"                     \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [al]                 \
    value [al]                      \
    modify exact [al];

u16 inc_word_asm(u32 * flags, u16 d);
#pragma aux inc_word_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "inc    ax"                     \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [ax]                 \
    value [ax]                      \
    modify exact [ax];

u32 inc_long_asm(u32 * flags, u32 d);
#pragma aux inc_long_asm =          \
    "push   [edi]"                  \
    "popf"                          \
    "inc    eax"                    \
    "pushf"                         \
    "pop    [edi]"                  \
    parm [edi] [eax]                \
    value [eax]                     \
    modify exact [eax];

u8 or_byte_asm(u32 * flags, u8 d, u8 s);
#pragma aux or_byte_asm =           \