prim_asm.h

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

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