| /**************************************************************************** |
| * |
| * 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 = \ |
| "push [edi]" \ |
| "popf" \ |
| "or al,bl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [al] [bl] \ |
| value [al] \ |
| modify exact [al bl]; |
| |
| u16 or_word_asm(u32 * flags, u16 d, u16 s); |
| #pragma aux or_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "or ax,bx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] [bx] \ |
| value [ax] \ |
| modify exact [ax bx]; |
| |
| u32 or_long_asm(u32 * flags, u32 d, u32 s); |
| #pragma aux or_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "or eax,ebx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] [ebx] \ |
| value [eax] \ |
| modify exact [eax ebx]; |
| |
| u8 neg_byte_asm(u32 * flags, u8 d); |
| #pragma aux neg_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "neg al" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [al] \ |
| value [al] \ |
| modify exact [al]; |
| |
| u16 neg_word_asm(u32 * flags, u16 d); |
| #pragma aux neg_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "neg ax" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] \ |
| value [ax] \ |
| modify exact [ax]; |
| |
| u32 neg_long_asm(u32 * flags, u32 d); |
| #pragma aux neg_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "neg eax" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] \ |
| value [eax] \ |
| modify exact [eax]; |
| |
| u8 not_byte_asm(u32 * flags, u8 d); |
| #pragma aux not_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "not al" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [al] \ |
| value [al] \ |
| modify exact [al]; |
| |
| u16 not_word_asm(u32 * flags, u16 d); |
| #pragma aux not_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "not ax" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] \ |
| value [ax] \ |
| modify exact [ax]; |
| |
| u32 not_long_asm(u32 * flags, u32 d); |
| #pragma aux not_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "not eax" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] \ |
| value [eax] \ |
| modify exact [eax]; |
| |
| u8 rcl_byte_asm(u32 * flags, u8 d, u8 s); |
| #pragma aux rcl_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "rcl al,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [al] [cl] \ |
| value [al] \ |
| modify exact [al cl]; |
| |
| u16 rcl_word_asm(u32 * flags, u16 d, u8 s); |
| #pragma aux rcl_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "rcl ax,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] [cl] \ |
| value [ax] \ |
| modify exact [ax cl]; |
| |
| u32 rcl_long_asm(u32 * flags, u32 d, u8 s); |
| #pragma aux rcl_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "rcl eax,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] [cl] \ |
| value [eax] \ |
| modify exact [eax cl]; |
| |
| u8 rcr_byte_asm(u32 * flags, u8 d, u8 s); |
| #pragma aux rcr_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "rcr al,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [al] [cl] \ |
| value [al] \ |
| modify exact [al cl]; |
| |
| u16 rcr_word_asm(u32 * flags, u16 d, u8 s); |
| #pragma aux rcr_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "rcr ax,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] [cl] \ |
| value [ax] \ |
| modify exact [ax cl]; |
| |
| u32 rcr_long_asm(u32 * flags, u32 d, u8 s); |
| #pragma aux rcr_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "rcr eax,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] [cl] \ |
| value [eax] \ |
| modify exact [eax cl]; |
| |
| u8 rol_byte_asm(u32 * flags, u8 d, u8 s); |
| #pragma aux rol_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "rol al,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [al] [cl] \ |
| value [al] \ |
| modify exact [al cl]; |
| |
| u16 rol_word_asm(u32 * flags, u16 d, u8 s); |
| #pragma aux rol_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "rol ax,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] [cl] \ |
| value [ax] \ |
| modify exact [ax cl]; |
| |
| u32 rol_long_asm(u32 * flags, u32 d, u8 s); |
| #pragma aux rol_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "rol eax,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] [cl] \ |
| value [eax] \ |
| modify exact [eax cl]; |
| |
| u8 ror_byte_asm(u32 * flags, u8 d, u8 s); |
| #pragma aux ror_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "ror al,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [al] [cl] \ |
| value [al] \ |
| modify exact [al cl]; |
| |
| u16 ror_word_asm(u32 * flags, u16 d, u8 s); |
| #pragma aux ror_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "ror ax,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] [cl] \ |
| value [ax] \ |
| modify exact [ax cl]; |
| |
| u32 ror_long_asm(u32 * flags, u32 d, u8 s); |
| #pragma aux ror_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "ror eax,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] [cl] \ |
| value [eax] \ |
| modify exact [eax cl]; |
| |
| u8 shl_byte_asm(u32 * flags, u8 d, u8 s); |
| #pragma aux shl_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "shl al,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [al] [cl] \ |
| value [al] \ |
| modify exact [al cl]; |
| |
| u16 shl_word_asm(u32 * flags, u16 d, u8 s); |
| #pragma aux shl_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "shl ax,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] [cl] \ |
| value [ax] \ |
| modify exact [ax cl]; |
| |
| u32 shl_long_asm(u32 * flags, u32 d, u8 s); |
| #pragma aux shl_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "shl eax,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] [cl] \ |
| value [eax] \ |
| modify exact [eax cl]; |
| |
| u8 shr_byte_asm(u32 * flags, u8 d, u8 s); |
| #pragma aux shr_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "shr al,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [al] [cl] \ |
| value [al] \ |
| modify exact [al cl]; |
| |
| u16 shr_word_asm(u32 * flags, u16 d, u8 s); |
| #pragma aux shr_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "shr ax,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] [cl] \ |
| value [ax] \ |
| modify exact [ax cl]; |
| |
| u32 shr_long_asm(u32 * flags, u32 d, u8 s); |
| #pragma aux shr_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "shr eax,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] [cl] \ |
| value [eax] \ |
| modify exact [eax cl]; |
| |
| u8 sar_byte_asm(u32 * flags, u8 d, u8 s); |
| #pragma aux sar_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "sar al,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [al] [cl] \ |
| value [al] \ |
| modify exact [al cl]; |
| |
| u16 sar_word_asm(u32 * flags, u16 d, u8 s); |
| #pragma aux sar_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "sar ax,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] [cl] \ |
| value [ax] \ |
| modify exact [ax cl]; |
| |
| u32 sar_long_asm(u32 * flags, u32 d, u8 s); |
| #pragma aux sar_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "sar eax,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] [cl] \ |
| value [eax] \ |
| modify exact [eax cl]; |
| |
| u16 shld_word_asm(u32 * flags, u16 d, u16 fill, u8 s); |
| #pragma aux shld_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "shld ax,dx,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] [dx] [cl] \ |
| value [ax] \ |
| modify exact [ax dx cl]; |
| |
| u32 shld_long_asm(u32 * flags, u32 d, u32 fill, u8 s); |
| #pragma aux shld_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "shld eax,edx,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] [edx] [cl] \ |
| value [eax] \ |
| modify exact [eax edx cl]; |
| |
| u16 shrd_word_asm(u32 * flags, u16 d, u16 fill, u8 s); |
| #pragma aux shrd_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "shrd ax,dx,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] [dx] [cl] \ |
| value [ax] \ |
| modify exact [ax dx cl]; |
| |
| u32 shrd_long_asm(u32 * flags, u32 d, u32 fill, u8 s); |
| #pragma aux shrd_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "shrd eax,edx,cl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] [edx] [cl] \ |
| value [eax] \ |
| modify exact [eax edx cl]; |
| |
| u8 sbb_byte_asm(u32 * flags, u8 d, u8 s); |
| #pragma aux sbb_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "sbb al,bl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [al] [bl] \ |
| value [al] \ |
| modify exact [al bl]; |
| |
| u16 sbb_word_asm(u32 * flags, u16 d, u16 s); |
| #pragma aux sbb_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "sbb ax,bx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] [bx] \ |
| value [ax] \ |
| modify exact [ax bx]; |
| |
| u32 sbb_long_asm(u32 * flags, u32 d, u32 s); |
| #pragma aux sbb_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "sbb eax,ebx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] [ebx] \ |
| value [eax] \ |
| modify exact [eax ebx]; |
| |
| u8 sub_byte_asm(u32 * flags, u8 d, u8 s); |
| #pragma aux sub_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "sub al,bl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [al] [bl] \ |
| value [al] \ |
| modify exact [al bl]; |
| |
| u16 sub_word_asm(u32 * flags, u16 d, u16 s); |
| #pragma aux sub_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "sub ax,bx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] [bx] \ |
| value [ax] \ |
| modify exact [ax bx]; |
| |
| u32 sub_long_asm(u32 * flags, u32 d, u32 s); |
| #pragma aux sub_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "sub eax,ebx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] [ebx] \ |
| value [eax] \ |
| modify exact [eax ebx]; |
| |
| void test_byte_asm(u32 * flags, u8 d, u8 s); |
| #pragma aux test_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "test al,bl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [al] [bl] \ |
| modify exact [al bl]; |
| |
| void test_word_asm(u32 * flags, u16 d, u16 s); |
| #pragma aux test_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "test ax,bx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] [bx] \ |
| modify exact [ax bx]; |
| |
| void test_long_asm(u32 * flags, u32 d, u32 s); |
| #pragma aux test_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "test eax,ebx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] [ebx] \ |
| modify exact [eax ebx]; |
| |
| u8 xor_byte_asm(u32 * flags, u8 d, u8 s); |
| #pragma aux xor_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "xor al,bl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [al] [bl] \ |
| value [al] \ |
| modify exact [al bl]; |
| |
| u16 xor_word_asm(u32 * flags, u16 d, u16 s); |
| #pragma aux xor_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "xor ax,bx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [ax] [bx] \ |
| value [ax] \ |
| modify exact [ax bx]; |
| |
| u32 xor_long_asm(u32 * flags, u32 d, u32 s); |
| #pragma aux xor_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "xor eax,ebx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| parm [edi] [eax] [ebx] \ |
| value [eax] \ |
| modify exact [eax ebx]; |
| |
| void imul_byte_asm(u32 * flags, u16 * ax, u8 d, u8 s); |
| #pragma aux imul_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "imul bl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| "mov [esi],ax" \ |
| parm [edi] [esi] [al] [bl] \ |
| modify exact [esi ax bl]; |
| |
| void imul_word_asm(u32 * flags, u16 * ax, u16 * dx, u16 d, u16 s); |
| #pragma aux imul_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "imul bx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| "mov [esi],ax" \ |
| "mov [ecx],dx" \ |
| parm [edi] [esi] [ecx] [ax] [bx]\ |
| modify exact [esi edi ax bx dx]; |
| |
| void imul_long_asm(u32 * flags, u32 * eax, u32 * edx, u32 d, u32 s); |
| #pragma aux imul_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "imul ebx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| "mov [esi],eax" \ |
| "mov [ecx],edx" \ |
| parm [edi] [esi] [ecx] [eax] [ebx] \ |
| modify exact [esi edi eax ebx edx]; |
| |
| void mul_byte_asm(u32 * flags, u16 * ax, u8 d, u8 s); |
| #pragma aux mul_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "mul bl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| "mov [esi],ax" \ |
| parm [edi] [esi] [al] [bl] \ |
| modify exact [esi ax bl]; |
| |
| void mul_word_asm(u32 * flags, u16 * ax, u16 * dx, u16 d, u16 s); |
| #pragma aux mul_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "mul bx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| "mov [esi],ax" \ |
| "mov [ecx],dx" \ |
| parm [edi] [esi] [ecx] [ax] [bx]\ |
| modify exact [esi edi ax bx dx]; |
| |
| void mul_long_asm(u32 * flags, u32 * eax, u32 * edx, u32 d, u32 s); |
| #pragma aux mul_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "mul ebx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| "mov [esi],eax" \ |
| "mov [ecx],edx" \ |
| parm [edi] [esi] [ecx] [eax] [ebx] \ |
| modify exact [esi edi eax ebx edx]; |
| |
| void idiv_byte_asm(u32 * flags, u8 * al, u8 * ah, u16 d, u8 s); |
| #pragma aux idiv_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "idiv bl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| "mov [esi],al" \ |
| "mov [ecx],ah" \ |
| parm [edi] [esi] [ecx] [ax] [bl]\ |
| modify exact [esi edi ax bl]; |
| |
| void idiv_word_asm(u32 * flags, u16 * ax, u16 * dx, u16 dlo, u16 dhi, u16 s); |
| #pragma aux idiv_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "idiv bx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| "mov [esi],ax" \ |
| "mov [ecx],dx" \ |
| parm [edi] [esi] [ecx] [ax] [dx] [bx]\ |
| modify exact [esi edi ax dx bx]; |
| |
| void idiv_long_asm(u32 * flags, u32 * eax, u32 * edx, u32 dlo, u32 dhi, u32 s); |
| #pragma aux idiv_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "idiv ebx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| "mov [esi],eax" \ |
| "mov [ecx],edx" \ |
| parm [edi] [esi] [ecx] [eax] [edx] [ebx]\ |
| modify exact [esi edi eax edx ebx]; |
| |
| void div_byte_asm(u32 * flags, u8 * al, u8 * ah, u16 d, u8 s); |
| #pragma aux div_byte_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "div bl" \ |
| "pushf" \ |
| "pop [edi]" \ |
| "mov [esi],al" \ |
| "mov [ecx],ah" \ |
| parm [edi] [esi] [ecx] [ax] [bl]\ |
| modify exact [esi edi ax bl]; |
| |
| void div_word_asm(u32 * flags, u16 * ax, u16 * dx, u16 dlo, u16 dhi, u16 s); |
| #pragma aux div_word_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "div bx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| "mov [esi],ax" \ |
| "mov [ecx],dx" \ |
| parm [edi] [esi] [ecx] [ax] [dx] [bx]\ |
| modify exact [esi edi ax dx bx]; |
| |
| void div_long_asm(u32 * flags, u32 * eax, u32 * edx, u32 dlo, u32 dhi, u32 s); |
| #pragma aux div_long_asm = \ |
| "push [edi]" \ |
| "popf" \ |
| "div ebx" \ |
| "pushf" \ |
| "pop [edi]" \ |
| "mov [esi],eax" \ |
| "mov [ecx],edx" \ |
| parm [edi] [esi] [ecx] [eax] [edx] [ebx]\ |
| modify exact [esi edi eax edx ebx]; |
| |
| #endif |
| |
| #endif /* __X86EMU_PRIM_ASM_H */ |
