prim_asm.h

uboot1.3.0 for s3c2440, 支持nand flash启动

    "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]"                  \