/* $Id: assyntax.h,v 1.2 2000-05-21 20:04:51 jeroen Exp $ */ #ifndef __ASSYNTAX_H__ #define __ASSYNTAX_H__ /* * Copyright 1992 Vrije Universiteit, The Netherlands * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose and without fee is hereby granted, 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 Vrije Universiteit not be used in * advertising or publicity pertaining to distribution of the software without * specific, written prior permission. The Vrije Universiteit makes no * representations about the suitability of this software for any purpose. * It is provided "as is" without express or implied warranty. * * The Vrije Universiteit DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO * EVENT SHALL The Vrije Universiteit 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. */ /* * assyntax.h * * Select the syntax appropriate to the 386 assembler being used * To add support for more assemblers add more columns to the CHOICE * macro. Note that register names must also have uppercase names * to avoid macro recursion. e.g., #define ah %ah recurses! * * NB 1. Some of the macros for certain assemblers imply that the code is to * run in protected mode!! Caveat emptor. * * NB 2. 486 specific instructions are not included. This is to discourage * their accidental use in code that is intended to run on 386 and 486 * systems. * * Supported assemblers: * * (a) AT&T SysVr4 as(1): define ATT_ASSEMBLER * (b) GNU Assembler gas: define GNU_ASSEMBLER (default) * (c) Amsterdam Compiler kit: define ACK_ASSEMBLER * (d) The Netwide Assembler: define NASM_ASSEMBLER * (e) Microsoft Assembler: define MASM_ASSEMBLER (UNTESTED!) * * The following naming conventions have been used to identify the various * data types: * _SR = segment register version * Integer: * _Q = quadword = 64 bits * _L = long = 32 bits * _W = short = 16 bits * _B = byte = 8 bits * Floating-point: * _X = m80real = 80 bits * _D = double = 64 bits * _S = single = 32 bits * * Author: Gregory J. Sharp, Sept 1992 * Vrije Universiteit, Amsterdam, The Netherlands * * [support for Intel syntax added by Josh Vanderhoof, 1999] */ #if !(defined(NASM_ASSEMBLER) || defined(MASM_ASSEMBLER)) #if !defined(ATT_ASSEMBLER) && !defined(GNU_ASSEMBLER) && !defined(ACK_ASSEMBLER) #define GNU_ASSEMBLER #endif #if (defined(__STDC__) && !defined(UNIXCPP)) || (defined (sun) && defined (i386) \ && defined (SVR4) && defined (__STDC__) && !defined (__GNUC__)) #define CONCAT(x, y) x ## y #else #define CONCAT(x, y) x/**/y #endif #ifdef ACK_ASSEMBLER /* Assume we write code for 32-bit protected mode! */ /* Redefine register names for GAS & AT&T assemblers */ #define AL al #define AH ah #define AX ax #define EAX ax #define BL bl #define BH bh #define BX bx #define EBX bx #define CL cl #define CH ch #define CX cx #define ECX cx #define DL dl #define DH dh #define DX dx #define EDX dx #define BP bp #define EBP bp #define SI si #define ESI si #define DI di #define EDI di #define SP sp #define ESP sp #define CS cs #define SS ss #define DS ds #define ES es #define FS fs #define GS gs /* Control Registers */ #define CR0 cr0 #define CR1 cr1 #define CR2 cr2 #define CR3 cr3 /* Debug Registers */ #define DR0 dr0 #define DR1 dr1 #define DR2 dr2 #define DR3 dr3 #define DR4 dr4 #define DR5 dr5 #define DR6 dr6 #define DR7 dr7 /* Floating-point Stack */ #define ST st #define AS_BEGIN .sect .text; .sect .rom; .sect .data; .sect .bss; .sect .text #define _WTOG o16 /* word toggle for _W instructions */ #define _LTOG /* long toggle for _L instructions */ #define ADDR_TOGGLE a16 #define OPSZ_TOGGLE o16 #define USE16 .use16 #define USE32 .use32 #define CHOICE(a,b,c) c #else /* AT&T or GAS */ /* Redefine register names for GAS & AT&T assemblers */ #define AL %al #define AH %ah #define AX %ax #define EAX %eax #define BL %bl #define BH %bh #define BX %bx #define EBX %ebx #define CL %cl #define CH %ch #define CX %cx #define ECX %ecx #define DL %dl #define DH %dh #define DX %dx #define EDX %edx #define BP %bp #define EBP %ebp #define SI %si #define ESI %esi #define DI %di #define EDI %edi #define SP %sp #define ESP %esp #define CS %cs #define SS %ss #define DS %ds #define ES %es #define FS %fs #define GS %gs /* Control Registers */ #define CR0 %cr0 #define CR1 %cr1 #define CR2 %cr2 #define CR3 %cr3 /* Debug Registers */ #define DR0 %db0 #define DR1 %db1 #define DR2 %db2 #define DR3 %db3 #define DR4 %db4 #define DR5 %db5 #define DR6 %db6 #define DR7 %db7 /* Floating-point Stack */ #define _STX0 %st(0) #define _STX1 %st(1) #define _STX2 %st(2) #define _STX3 %st(3) #define _STX4 %st(4) #define _STX5 %st(5) #define _STX6 %st(6) #define _STX7 %st(7) #define ST(x) CONCAT(_STX,x) /* MMX Registers */ #define MM0 %mm0 #define MM1 %mm1 #define MM2 %mm2 #define MM3 %mm3 #define MM4 %mm4 #define MM5 %mm5 #define MM6 %mm6 #define MM7 %mm7 /* SSE Registers */ #define XMM0 %xmm0 #define XMM1 %xmm1 #define XMM2 %xmm2 #define XMM3 %xmm3 #define XMM4 %xmm4 #define XMM5 %xmm5 #define XMM6 %xmm6 #define XMM7 %xmm7 #define AS_BEGIN #define USE16 #define USE32 #ifdef GNU_ASSEMBLER #define ADDR_TOGGLE aword #define OPSZ_TOGGLE word #define CHOICE(a,b,c) b #else /* * AT&T ASSEMBLER SYNTAX * ********************* */ #define CHOICE(a,b,c) a #define ADDR_TOGGLE addr16 #define OPSZ_TOGGLE data16 #endif /* GNU_ASSEMBLER */ #endif /* ACK_ASSEMBLER */ #if defined(__QNX__) || defined(Lynx) || (defined(SYSV) || defined(SVR4)) && !defined(ACK_ASSEMBLER) || defined(__ELF__) || defined(__GNU__) #define GLNAME(a) a #else #define GLNAME(a) CONCAT(_,a) #endif /****************************************/ /* */ /* Select the various choices */ /* */ /****************************************/ /* Redefine assembler directives */ /*********************************/ #define GLOBL CHOICE(.globl, .globl, .extern) /* #define ALIGNTEXT32 CHOICE(.align 32, .align ARG2(5,0x90), .align 32) */ #define ALIGNTEXT32 CHOICE(.align 32, .balign 32, .align 32) #define ALIGNTEXT16 CHOICE(.align 16, .balign 16, .align 16) #define ALIGNTEXT8 CHOICE(.align 8, .balign 8, .align 8) #define ALIGNTEXT4 CHOICE(.align 4, .balign 4, .align 4) #define ALIGNTEXT2 CHOICE(.align 2, .balign 2, .align 2) /* ALIGNTEXT4ifNOP is the same as ALIGNTEXT4, but only if the space is * guaranteed to be filled with NOPs. Otherwise it does nothing. */ #define ALIGNTEXT32ifNOP CHOICE(.align 32, .balign ARG2(32,0x90), /*can't do it*/) #define ALIGNTEXT16ifNOP CHOICE(.align 16, .balign ARG2(16,0x90), /*can't do it*/) #define ALIGNTEXT8ifNOP CHOICE(.align 8, .balign ARG2(8,0x90), /*can't do it*/) #define ALIGNTEXT4ifNOP CHOICE(.align 4, .balign ARG2(4,0x90), /*can't do it*/) #define ALIGNDATA32 CHOICE(.align 32, .balign ARG2(32,0x0), .align 32) #define ALIGNDATA16 CHOICE(.align 16, .balign ARG2(16,0x0), .align 16) #define ALIGNDATA8 CHOICE(.align 8, .balign ARG2(8,0x0), .align 8) #define ALIGNDATA4 CHOICE(.align 4, .balign ARG2(4,0x0), .align 4) #define ALIGNDATA2 CHOICE(.align 2, .balign ARG2(2,0x0), .align 2) #define FILE(s) CHOICE(.file s, .file s, .file s) #define STRING(s) CHOICE(.string s, .asciz s, .asciz s) #define D_LONG CHOICE(.long, .long, .data4) #define D_WORD CHOICE(.value, .short, .data2) #define D_BYTE CHOICE(.byte, .byte, .data1) #define SPACE CHOICE(.comm, .space, .space) #define COMM CHOICE(.comm, .comm, .comm) #define SEG_DATA CHOICE(.data, .data, .sect .data) #define SEG_TEXT CHOICE(.text, .text, .sect .text) #define SEG_BSS CHOICE(.bss, .bss, .sect .bss) #ifdef GNU_ASSEMBLER #define D_SPACE(n) . = . + n #else #define D_SPACE(n) .space n #endif /* Addressing Modes */ /* Immediate Mode */ #define ADDR(a) CHOICE(CONCAT($,a), CONCAT($,a), a) #define CONST(a) CHOICE(CONCAT($,a), CONCAT($,a), a) /* Indirect Mode */ #define CONTENT(a) CHOICE(a, a, (a)) /* take contents of variable */ #define REGIND(a) CHOICE((a), (a), (a)) /* Register a indirect */ /* Register b indirect plus displacement a */ #define REGOFF(a, b) CHOICE(a(b), a(b), a(b)) /* Reg indirect Base + Index + Displacement - this is mainly for 16-bit mode * which has no scaling */ #define REGBID(b,i,d) CHOICE(d(b,i), d(b,i), d(b)(i)) /* Reg indirect Base + (Index * Scale) + Displacement */ #define REGBISD(b,i,s,d) CHOICE(d(b,i,s), d(b,i,s), d(b)(i*s)) /* Displaced Scaled Index: */ #define REGDIS(d,i,s) CHOICE(d(,i,s), d(,i,s), d(i * s)) /* Indexed Base: */ #define REGBI(b,i) CHOICE((b,i), (b,i), (b)(i)) /* Displaced Base: */ #define REGDB(d,b) CHOICE(d(b), d(b), d(b)) /* Variable indirect: */ #define VARINDIRECT(var) CHOICE(*var, *var, (var)) /* Use register contents as jump/call target: */ #define CODEPTR(reg) CHOICE(*reg, *reg, reg) /* For expressions requiring bracketing * eg. (CRT0_PM | CRT_EM) */ #define EXPR(a) CHOICE([a], (a), [a]) #define ENOT(a) CHOICE(0!a, ~a, ~a) #define EMUL(a,b) CHOICE(a\*b, a*b, a*b) #define EDIV(a,b) CHOICE(a\/b, a/b, a/b) /* * We have to beat the problem of commas within arguments to choice. * eg. choice (add a,b, add b,a) will get argument mismatch. Luckily ANSI * and other known cpp definitions evaluate arguments before substitution * so the following works. */ #define ARG2(a, b) a,b #define ARG3(a,b,c) a,b,c /* Redefine assembler commands */ #define AAA CHOICE(aaa, aaa, aaa) #define AAD CHOICE(aad, aad, aad) #define AAM CHOICE(aam, aam, aam) #define AAS CHOICE(aas, aas, aas) #define ADC_L(a, b) CHOICE(adcl ARG2(a,b), adcl ARG2(a,b), _LTOG adc ARG2(b,a)) #define ADC_W(a, b) CHOICE(adcw ARG2(a,b), adcw ARG2(a,b), _WTOG adc ARG2(b,a)) #define ADC_B(a, b) CHOICE(adcb ARG2(a,b), adcb ARG2(a,b), adcb ARG2(b,a)) #define ADD_L(a, b) CHOICE(addl ARG2(a,b), addl ARG2(a,b), _LTOG add ARG2(b,a)) #define ADD_W(a, b) CHOICE(addw ARG2(a,b), addw ARG2(a,b), _WTOG add ARG2(b,a)) #define ADD_B(a, b) CHOICE(addb ARG2(a,b), addb ARG2(a,b), addb ARG2(b,a)) #define AND_L(a, b) CHOICE(andl ARG2(a,b), andl ARG2(a,b), _LTOG and ARG2(b,a)) #define AND_W(a, b) CHOICE(andw ARG2(a,b), andw ARG2(a,b), _WTOG and ARG2(b,a)) #define AND_B(a, b) CHOICE(andb ARG2(a,b), andb ARG2(a,b), andb ARG2(b,a)) #define ARPL(a,b) CHOICE(arpl ARG2(a,b), arpl ARG2(a,b), arpl ARG2(b,a)) #define BOUND_L(a, b) CHOICE(boundl ARG2(a,b), boundl ARG2(b,a), _LTOG bound ARG2(b,a)) #define BOUND_W(a, b) CHOICE(boundw ARG2(a,b), boundw ARG2(b,a), _WTOG bound ARG2(b,a)) #define BSF_L(a, b) CHOICE(bsfl ARG2(a,b), bsfl ARG2(a,b), _LTOG bsf ARG2(b,a)) #define BSF_W(a, b) CHOICE(bsfw ARG2(a,b), bsfw ARG2(a,b), _WTOG bsf ARG2(b,a)) #define BSR_L(a, b) CHOICE(bsrl ARG2(a,b), bsrl ARG2(a,b), _LTOG bsr ARG2(b,a)) #define BSR_W(a, b) CHOICE(bsrw ARG2(a,b), bsrw ARG2(a,b), _WTOG bsr ARG2(b,a)) #define BT_L(a, b) CHOICE(btl ARG2(a,b), btl ARG2(a,b), _LTOG bt ARG2(b,a)) #define BT_W(a, b) CHOICE(btw ARG2(a,b), btw ARG2(a,b), _WTOG bt ARG2(b,a)) #define BTC_L(a, b) CHOICE(btcl ARG2(a,b), btcl ARG2(a,b), _LTOG btc ARG2(b,a)) #define BTC_W(a, b) CHOICE(btcw ARG2(a,b), btcw ARG2(a,b), _WTOG btc ARG2(b,a)) #define BTR_L(a, b) CHOICE(btrl ARG2(a,b), btrl ARG2(a,b), _LTOG btr ARG2(b,a)) #define BTR_W(a, b) CHOICE(btrw ARG2(a,b), btrw ARG2(a,b), _WTOG btr ARG2(b,a)) #define BTS_L(a, b) CHOICE(btsl ARG2(a,b), btsl ARG2(a,b), _LTOG bts ARG2(b,a)) #define BTS_W(a, b) CHOICE(btsw ARG2(a,b), btsw ARG2(a,b), _WTOG bts ARG2(b,a)) #define CALL(a) CHOICE(call a, call a, call a) #define CALLF(s,a) CHOICE(lcall ARG2(s,a), lcall ARG2(s,a), callf s:a) #define CBW CHOICE(cbtw, cbw, cbw) #define CWDE CHOICE(cwtd, cwde, cwde) #define CLC CHOICE(clc, clc, clc) #define CLD CHOICE(cld, cld, cld) #define CLI CHOICE(cli, cli, cli) #define CLTS CHOICE(clts, clts, clts) #define CMC CHOICE(cmc, cmc, cmc) #define CMP_L(a, b) CHOICE(cmpl ARG2(a,b), cmpl ARG2(a,b), _LTOG cmp ARG2(b,a)) #define CMP_W(a, b) CHOICE(cmpw ARG2(a,b), cmpw ARG2(a,b), _WTOG cmp ARG2(b,a)) #define CMP_B(a, b) CHOICE(cmpb ARG2(a,b), cmpb ARG2(a,b), cmpb ARG2(b,a)) #define CMPS_L CHOICE(cmpsl, cmpsl, _LTOG cmps) #define CMPS_W CHOICE(cmpsw, cmpsw, _WTOG cmps) #define CMPS_B CHOICE(cmpsb, cmpsb, cmpsb) #define CWD CHOICE(cwtl, cwd, cwd) #define CDQ CHOICE(cltd, cdq, cdq) #define DAA CHOICE(daa, daa, daa) #define DAS CHOICE(das, das, das) #define DEC_L(a) CHOICE(decl a, decl a, _LTOG dec a) #define DEC_W(a) CHOICE(decw a, decw a, _WTOG dec a) #define DEC_B(a) CHOICE(decb a, decb a, decb a) #define DIV_L(a) CHOICE(divl a, divl a, div a) #define DIV_W(a) CHOICE(divw a, divw a, div a) #define DIV_B(a) CHOICE(divb a, divb a, divb a) #define ENTER(a,b) CHOICE(enter ARG2(a,b), enter ARG2(a,b), enter ARG2(b,a)) #define HLT CHOICE(hlt, hlt, hlt) #define IDIV_L(a) CHOICE(idivl a, idivl a, _LTOG idiv a) #define IDIV_W(a) CHOICE(idivw a, idivw a, _WTOG idiv a) #define IDIV_B(a) CHOICE(idivb a, idivb a, idivb a) /* More forms than this for imul!! */ #define IMUL_L(a, b) CHOICE(imull ARG2(a,b), imull ARG2(a,b), _LTOG imul ARG2(b,a)) #define IMUL_W(a, b) CHOICE(imulw ARG2(a,b), imulw ARG2(a,b), _WTOG imul ARG2(b,a)) #define IMUL_B(a) CHOICE(imulb a, imulb a, imulb a) #define IN_L CHOICE(inl (DX), inl ARG2(DX,EAX), _LTOG in DX) #define IN_W CHOICE(inw (DX), inw ARG2(DX,AX), _WTOG in DX) #define IN_B CHOICE(inb (DX), inb ARG2(DX,AL), inb DX) /* Please AS code writer: use the following ONLY, if you refer to ports<256 * directly, but not in IN1_W(DX), for instance, even if IN1_ looks nicer */ #if defined (sun) #define IN1_L(a) CHOICE(inl (a), inl ARG2(a,EAX), _LTOG in a) #define IN1_W(a) CHOICE(inw (a), inw ARG2(a,AX), _WTOG in a) #define IN1_B(a) CHOICE(inb (a), inb ARG2(a,AL), inb a) #else #define IN1_L(a) CHOICE(inl a, inl ARG2(a,EAX), _LTOG in a) #define IN1_W(a) CHOICE(inw a, inw ARG2(a,AX), _WTOG in a) #define IN1_B(a) CHOICE(inb a, inb ARG2(a,AL), inb a) #endif #define INC_L(a) CHOICE(incl a, incl a, _LTOG inc a) #define INC_W(a) CHOICE(incw a, incw a, _WTOG inc a) #define INC_B(a) CHOICE(incb a, incb a, incb a) #define INS_L CHOICE(insl, insl, _LTOG ins) #define INS_W CHOICE(insw, insw, _WTOG ins) #define INS_B CHOICE(insb, insb, insb) #define INT(a) CHOICE(int a, int a, int a) #define INT3 CHOICE(int CONST(3), int3, int CONST(3)) #define INTO CHOICE(into, into, into) #define IRET CHOICE(iret, iret, iret) #define IRETD CHOICE(iret, iret, iretd) #define JA(a) CHOICE(ja a, ja a, ja a) #define JAE(a) CHOICE(jae a, jae a, jae a) #define JB(a) CHOICE(jb a, jb a, jb a) #define JBE(a) CHOICE(jbe a, jbe a, jbe a) #define JC(a) CHOICE(jc a, jc a, jc a) #define JE(a) CHOICE(je a, je a, je a) #define JG(a) CHOICE(jg a, jg a, jg a) #define JGE(a) CHOICE(jge a, jge a, jge a) #define JL(a) CHOICE(jl a, jl a, jl a) #define JLE(a) CHOICE(jle a, jle a, jle a) #define JNA(a) CHOICE(jna a, jna a, jna a) #define JNAE(a) CHOICE(jnae a, jnae a, jnae a) #define JNB(a) CHOICE(jnb a, jnb a, jnb a) #define JNBE(a) CHOICE(jnbe a, jnbe a, jnbe a) #define JNC(a) CHOICE(jnc a, jnc a, jnc a) #define JNE(a) CHOICE(jne a, jne a, jne a) #define JNG(a) CHOICE(jng a, jng a, jng a) #define JNGE(a) CHOICE(jnge a, jnge a, jnge a) #define JNL(a) CHOICE(jnl a, jnl a, jnl a) #define JNLE(a) CHOICE(jnle a, jnle a, jnle a) #define JNO(a) CHOICE(jno a, jno a, jno a) #define JNP(a) CHOICE(jnp a, jnp a, jnp a) #define JNS(a) CHOICE(jns a, jns a, jns a) #define JNZ(a) CHOICE(jnz a, jnz a, jnz a) #define JO(a) CHOICE(jo a, jo a, jo a) #define JP(a) CHOICE(jp a, jp a, jp a) #define JPE(a) CHOICE(jpe a, jpe a, jpe a) #define JPO(a) CHOICE(jpo a, jpo a, jpo a) #define JS(a) CHOICE(js a, js a, js a) #define JZ(a) CHOICE(jz a, jz a, jz a) #define JMP(a) CHOICE(jmp a, jmp a, jmp a) #define JMPF(s,a) CHOICE(ljmp ARG2(s,a), ljmp ARG2(s,a), jmpf s:a) #define LAHF CHOICE(lahf, lahf, lahf) #if !defined(_REAL_MODE) && !defined(_V86_MODE) #define LAR(a, b) CHOICE(lar ARG2(a, b), lar ARG2(a, b), lar ARG2(b, a)) #endif #define LEA_L(a, b) CHOICE(leal ARG2(a,b), leal ARG2(a,b), _LTOG lea ARG2(b,a)) #define LEA_W(a, b) CHOICE(leaw ARG2(a,b), leaw ARG2(a,b), _WTOG lea ARG2(b,a)) #define LEAVE CHOICE(leave, leave, leave) #define LGDT(a) CHOICE(lgdt a, lgdt a, lgdt a) #define LIDT(a) CHOICE(lidt a, lidt a, lidt a) #define LDS(a, b) CHOICE(ldsl ARG2(a,b), lds ARG2(a,b), lds ARG2(b,a)) #define LES(a, b) CHOICE(lesl ARG2(a,b), les ARG2(a,b), les ARG2(b,a)) #define LFS(a, b) CHOICE(lfsl ARG2(a,b), lfs ARG2(a,b), lfs ARG2(b,a)) #define LGS(a, b) CHOICE(lgsl ARG2(a,b), lgs ARG2(a,b), lgs ARG2(b,a)) #define LSS(a, b) CHOICE(lssl ARG2(a,b), lss ARG2(a,b), lss ARG2(b,a)) #define LLDT(a) CHOICE(lldt a, lldt a, lldt a) #define LMSW(a) CHOICE(lmsw a, lmsw a, lmsw a) #define LOCK CHOICE(lock, lock, lock) #define LODS_L CHOICE(lodsl, lodsl, _LTOG lods) #define LODS_W CHOICE(lodsw, lodsw, _WTOG lods) #define LODS_B CHOICE(lodsb, lodsb, lodsb) #define LOOP(a) CHOICE(loop a, loop a, loop a) #define LOOPE(a) CHOICE(loope a, loope a, loope a) #define LOOPZ(a) CHOICE(loopz a, loopz a, loopz a) #define LOOPNE(a) CHOICE(loopne a, loopne a, loopne a) #define LOOPNZ(a) CHOICE(loopnz a, loopnz a, loopnz a) #if !defined(_REAL_MODE) && !defined(_V86_MODE) #define LSL(a, b) CHOICE(lsl ARG2(a,b), lsl ARG2(a,b), lsl ARG2(b,a)) #endif #define LTR(a) CHOICE(ltr a, ltr a, ltr a) #define MOV_SR(a, b) CHOICE(movw ARG2(a,b), mov ARG2(a,b), mov ARG2(b,a)) #define MOV_L(a, b) CHOICE(movl ARG2(a,b), movl ARG2(a,b), _LTOG mov ARG2(b,a)) #define MOV_W(a, b) CHOICE(movw ARG2(a,b), movw ARG2(a,b), _WTOG mov ARG2(b,a)) #define MOV_B(a, b) CHOICE(movb ARG2(a,b), movb ARG2(a,b), movb ARG2(b,a)) #define MOVS_L CHOICE(movsl, movsl, _LTOG movs) #define MOVS_W CHOICE(movsw, movsw, _WTOG movs) #define MOVS_B CHOICE(movsb, movsb, movsb) #define MOVSX_BL(a, b) CHOICE(movsbl ARG2(a,b), movsbl ARG2(a,b), movsx ARG2(b,a)) #define MOVSX_BW(a, b) CHOICE(movsbw ARG2(a,b), movsbw ARG2(a,b), movsx ARG2(b,a)) #define MOVSX_WL(a, b) CHOICE(movswl ARG2(a,b), movswl ARG2(a,b), movsx ARG2(b,a)) #define MOVZX_BL(a, b) CHOICE(movzbl ARG2(a,b), movzbl ARG2(a,b), movzx ARG2(b,a)) #define MOVZX_BW(a, b) CHOICE(movzbw ARG2(a,b), movzbw ARG2(a,b), movzx ARG2(b,a)) #define MOVZX_WL(a, b) CHOICE(movzwl ARG2(a,b), movzwl ARG2(a,b), movzx ARG2(b,a)) #define MUL_L(a) CHOICE(mull a, mull a, _LTOG mul a) #define MUL_W(a) CHOICE(mulw a, mulw a, _WTOG mul a) #define MUL_B(a) CHOICE(mulb a, mulb a, mulb a) #define NEG_L(a) CHOICE(negl a, negl a, _LTOG neg a) #define NEG_W(a) CHOICE(negw a, negw a, _WTOG neg a) #define NEG_B(a) CHOICE(negb a, negb a, negb a) #define NOP CHOICE(nop, nop, nop) #define NOT_L(a) CHOICE(notl a, notl a, _LTOG not a) #define NOT_W(a) CHOICE(notw a, notw a, _WTOG not a) #define NOT_B(a) CHOICE(notb a, notb a, notb a) #define OR_L(a,b) CHOICE(orl ARG2(a,b), orl ARG2(a,b), _LTOG or ARG2(b,a)) #define OR_W(a,b) CHOICE(orw ARG2(a,b), orw ARG2(a,b), _WTOG or ARG2(b,a)) #define OR_B(a,b) CHOICE(orb ARG2(a,b), orb ARG2(a,b), orb ARG2(b,a)) #define OUT_L CHOICE(outl (DX), outl ARG2(EAX,DX), _LTOG out DX) #define OUT_W CHOICE(outw (DX), outw ARG2(AX,DX), _WTOG out DX) #define OUT_B CHOICE(outb (DX), outb ARG2(AL,DX), outb DX) /* Please AS code writer: use the following ONLY, if you refer to ports<256 * directly, but not in OUT1_W(DX), for instance, even if OUT1_ looks nicer */ #define OUT1_L(a) CHOICE(outl (a), outl ARG2(EAX,a), _LTOG out a) #define OUT1_W(a) CHOICE(outw (a), outw ARG2(AX,a), _WTOG out a) #define OUT1_B(a) CHOICE(outb (a), outb ARG2(AL,a), outb a) #define OUTS_L CHOICE(outsl, outsl, _LTOG outs) #define OUTS_W CHOICE(outsw, outsw, _WTOG outs) #define OUTS_B CHOICE(outsb, outsb, outsb) #define POP_SR(a) CHOICE(pop a, pop a, pop a) #define POP_L(a) CHOICE(popl a, popl a, _LTOG pop a) #define POP_W(a) CHOICE(popw a, popw a, _WTOG pop a) #define POPA_L CHOICE(popal, popal, _LTOG popa) #define POPA_W CHOICE(popaw, popaw, _WTOG popa) #define POPF_L CHOICE(popfl, popfl, _LTOG popf) #define POPF_W CHOICE(popfw, popfw, _WTOG popf) #define PUSH_SR(a) CHOICE(push a, push a, push a) #define PUSH_L(a) CHOICE(pushl a, pushl a, _LTOG push a) #define PUSH_W(a) CHOICE(pushw a, pushw a, _WTOG push a) #define PUSH_B(a) CHOICE(push a, pushb a, push a) #define PUSHA_L CHOICE(pushal, pushal, _LTOG pusha) #define PUSHA_W CHOICE(pushaw, pushaw, _WTOG pusha) #define PUSHF_L CHOICE(pushfl, pushfl, _LTOG pushf) #define PUSHF_W CHOICE(pushfw, pushfw, _WTOG pushf) #define RCL_L(a, b) CHOICE(rcll ARG2(a,b), rcll ARG2(a,b), _LTOG rcl ARG2(b,a)) #define RCL_W(a, b) CHOICE(rclw ARG2(a,b), rclw ARG2(a,b), _WTOG rcl ARG2(b,a)) #define RCL_B(a, b) CHOICE(rclb ARG2(a,b), rclb ARG2(a,b), rclb ARG2(b,a)) #define RCR_L(a, b) CHOICE(rcrl ARG2(a,b), rcrl ARG2(a,b), _LTOG rcr ARG2(b,a)) #define RCR_W(a, b) CHOICE(rcrw ARG2(a,b), rcrw ARG2(a,b), _WTOG rcr ARG2(b,a)) #define RCR_B(a, b) CHOICE(rcrb ARG2(a,b), rcrb ARG2(a,b), rcrb ARG2(b,a)) #define ROL_L(a, b) CHOICE(roll ARG2(a,b), roll ARG2(a,b), _LTOG rol ARG2(b,a)) #define ROL_W(a, b) CHOICE(rolw ARG2(a,b), rolw ARG2(a,b), _WTOG rol ARG2(b,a)) #define ROL_B(a, b) CHOICE(rolb ARG2(a,b), rolb ARG2(a,b), rolb ARG2(b,a)) #define ROR_L(a, b) CHOICE(rorl ARG2(a,b), rorl ARG2(a,b), _LTOG ror ARG2(b,a)) #define ROR_W(a, b) CHOICE(rorw ARG2(a,b), rorw ARG2(a,b), _WTOG ror ARG2(b,a)) #define ROR_B(a, b) CHOICE(rorb ARG2(a,b), rorb ARG2(a,b), rorb ARG2(b,a)) #define REP CHOICE(rep ;, rep ;, repe) #define REPE CHOICE(repz ;, repe ;, repe) #define REPNE CHOICE(repnz ;, repne ;, repne) #define REPNZ REPNE #define REPZ REPE #define RET CHOICE(ret, ret, ret) #define SAHF CHOICE(sahf, sahf, sahf) #define SAL_L(a, b) CHOICE(sall ARG2(a,b), sall ARG2(a,b), _LTOG sal ARG2(b,a)) #define SAL_W(a, b) CHOICE(salw ARG2(a,b), salw ARG2(a,b), _WTOG sal ARG2(b,a)) #define SAL_B(a, b) CHOICE(salb ARG2(a,b), salb ARG2(a,b), salb ARG2(b,a)) #define SAR_L(a, b) CHOICE(sarl ARG2(a,b), sarl ARG2(a,b), _LTOG sar ARG2(b,a)) #define SAR_W(a, b) CHOICE(sarw ARG2(a,b), sarw ARG2(a,b), _WTOG sar ARG2(b,a)) #define SAR_B(a, b) CHOICE(sarb ARG2(a,b), sarb ARG2(a,b), sarb ARG2(b,a)) #define SBB_L(a, b) CHOICE(sbbl ARG2(a,b), sbbl ARG2(a,b), _LTOG sbb ARG2(b,a)) #define SBB_W(a, b) CHOICE(sbbw ARG2(a,b), sbbw ARG2(a,b), _WTOG sbb ARG2(b,a)) #define SBB_B(a, b) CHOICE(sbbb ARG2(a,b), sbbb ARG2(a,b), sbbb ARG2(b,a)) #define SCAS_L CHOICE(scasl, scasl, _LTOG scas) #define SCAS_W CHOICE(scasw, scasw, _WTOG scas) #define SCAS_B CHOICE(scasb, scasb, scasb) #define SETA(a) CHOICE(seta a, seta a, seta a) #define SETAE(a) CHOICE(setae a, setae a, setae a) #define SETB(a) CHOICE(setb a, setb a, setb a) #define SETBE(a) CHOICE(setbe a, setbe a, setbe a) #define SETC(a) CHOICE(setc a, setb a, setb a) #define SETE(a) CHOICE(sete a, sete a, sete a) #define SETG(a) CHOICE(setg a, setg a, setg a) #define SETGE(a) CHOICE(setge a, setge a, setge a) #define SETL(a) CHOICE(setl a, setl a, setl a) #define SETLE(a) CHOICE(setle a, setle a, setle a) #define SETNA(a) CHOICE(setna a, setna a, setna a) #define SETNAE(a) CHOICE(setnae a, setnae a, setnae a) #define SETNB(a) CHOICE(setnb a, setnb a, setnb a) #define SETNBE(a) CHOICE(setnbe a, setnbe a, setnbe a) #define SETNC(a) CHOICE(setnc a, setnb a, setnb a) #define SETNE(a) CHOICE(setne a, setne a, setne a) #define SETNG(a) CHOICE(setng a, setng a, setng a) #define SETNGE(a) CHOICE(setnge a, setnge a, setnge a) #define SETNL(a) CHOICE(setnl a, setnl a, setnl a) #define SETNLE(a) CHOICE(setnle a, setnle a, setnle a) #define SETNO(a) CHOICE(setno a, setno a, setno a) #define SETNP(a) CHOICE(setnp a, setnp a, setnp a) #define SETNS(a) CHOICE(setns a, setns a, setna a) #define SETNZ(a) CHOICE(setnz a, setnz a, setnz a) #define SETO(a) CHOICE(seto a, seto a, seto a) #define SETP(a) CHOICE(setp a, setp a, setp a) #define SETPE(a) CHOICE(setpe a, setpe a, setpe a) #define SETPO(a) CHOICE(setpo a, setpo a, setpo a) #define SETS(a) CHOICE(sets a, sets a, seta a) #define SETZ(a) CHOICE(setz a, setz a, setz a) #define SGDT(a) CHOICE(sgdt a, sgdt a, sgdt a) #define SIDT(a) CHOICE(sidt a, sidt a, sidt a) #define SHL_L(a, b) CHOICE(shll ARG2(a,b), shll ARG2(a,b), _LTOG shl ARG2(b,a)) #define SHL_W(a, b) CHOICE(shlw ARG2(a,b), shlw ARG2(a,b), _WTOG shl ARG2(b,a)) #define SHL_B(a, b) CHOICE(shlb ARG2(a,b), shlb ARG2(a,b), shlb ARG2(b,a)) #define SHLD_L(a,b,c) CHOICE(shldl ARG3(a,b,c), shldl ARG3(a,b,c), _LTOG shld ARG3(c,b,a)) #define SHLD2_L(a,b) CHOICE(shldl ARG2(a,b), shldl ARG3(CL,a,b), _LTOG shld ARG3(b,a,CL)) #define SHLD_W(a,b,c) CHOICE(shldw ARG3(a,b,c), shldw ARG3(a,b,c), _WTOG shld ARG3(c,b,a)) #define SHLD2_W(a,b) CHOICE(shldw ARG2(a,b), shldw ARG3(CL,a,b), _WTOG shld ARG3(b,a,CL)) #define SHR_L(a, b) CHOICE(shrl ARG2(a,b), shrl ARG2(a,b), _LTOG shr ARG2(b,a)) #define SHR_W(a, b) CHOICE(shrw ARG2(a,b), shrw ARG2(a,b), _WTOG shr ARG2(b,a)) #define SHR_B(a, b) CHOICE(shrb ARG2(a,b), shrb ARG2(a,b), shrb ARG2(b,a)) #define SHRD_L(a,b,c) CHOICE(shrdl ARG3(a,b,c), shrdl ARG3(a,b,c), _LTOG shrd ARG3(c,b,a)) #define SHRD2_L(a,b) CHOICE(shrdl ARG2(a,b), shrdl ARG3(CL,a,b), _LTOG shrd ARG3(b,a,CL)) #define SHRD_W(a,b,c) CHOICE(shrdw ARG3(a,b,c), shrdw ARG3(a,b,c), _WTOG shrd ARG3(c,b,a)) #define SHRD2_W(a,b) CHOICE(shrdw ARG2(a,b), shrdw ARG3(CL,a,b), _WTOG shrd ARG3(b,a,CL)) #define SLDT(a) CHOICE(sldt a, sldt a, sldt a) #define SMSW(a) CHOICE(smsw a, smsw a, smsw a) #define STC CHOICE(stc, stc, stc) #define STD CHOICE(std, std, std) #define STI CHOICE(sti, sti, sti) #define STOS_L CHOICE(stosl, stosl, _LTOG stos) #define STOS_W CHOICE(stosw, stosw, _WTOG stos) #define STOS_B CHOICE(stosb, stosb, stosb) #define STR(a) CHOICE(str a, str a, str a) #define SUB_L(a, b) CHOICE(subl ARG2(a,b), subl ARG2(a,b), _LTOG sub ARG2(b,a)) #define SUB_W(a, b) CHOICE(subw ARG2(a,b), subw ARG2(a,b), _WTOG sub ARG2(b,a)) #define SUB_B(a, b) CHOICE(subb ARG2(a,b), subb ARG2(a,b), subb ARG2(b,a)) #define TEST_L(a, b) CHOICE(testl ARG2(a,b), testl ARG2(a,b), _LTOG test ARG2(b,a)) #define TEST_W(a, b) CHOICE(testw ARG2(a,b), testw ARG2(a,b), _WTOG test ARG2(b,a)) #define TEST_B(a, b) CHOICE(testb ARG2(a,b), testb ARG2(a,b), testb ARG2(b,a)) #define VERR(a) CHOICE(verr a, verr a, verr a) #define VERW(a) CHOICE(verw a, verw a, verw a) #define WAIT CHOICE(wait, wait, wait) #define XCHG_L(a, b) CHOICE(xchgl ARG2(a,b), xchgl ARG2(a,b), _LTOG xchg ARG2(b,a)) #define XCHG_W(a, b) CHOICE(xchgw ARG2(a,b), xchgw ARG2(a,b), _WTOG xchg ARG2(b,a)) #define XCHG_B(a, b) CHOICE(xchgb ARG2(a,b), xchgb ARG2(a,b), xchgb ARG2(b,a)) #define XLAT CHOICE(xlat, xlat, xlat) #define XOR_L(a, b) CHOICE(xorl ARG2(a,b), xorl ARG2(a,b), _LTOG xor ARG2(b,a)) #define XOR_W(a, b) CHOICE(xorw ARG2(a,b), xorw ARG2(a,b), _WTOG xor ARG2(b,a)) #define XOR_B(a, b) CHOICE(xorb ARG2(a,b), xorb ARG2(a,b), xorb ARG2(b,a)) /* Floating Point Instructions */ #define F2XM1 CHOICE(f2xm1, f2xm1, f2xm1) #define FABS CHOICE(fabs, fabs, fabs) #define FADD_D(a) CHOICE(faddl a, faddl a, faddd a) #define FADD_S(a) CHOICE(fadds a, fadds a, fadds a) #define FADD2(a, b) CHOICE(fadd ARG2(a,b), fadd ARG2(a,b), fadd ARG2(b,a)) #define FADDP(a, b) CHOICE(faddp ARG2(a,b), faddp ARG2(a,b), faddp ARG2(b,a)) #define FIADD_L(a) CHOICE(fiaddl a, fiaddl a, fiaddl a) #define FIADD_W(a) CHOICE(fiadd a, fiadds a, fiadds a) #define FBLD(a) CHOICE(fbld a, fbld a, fbld a) #define FBSTP(a) CHOICE(fbstp a, fbstp a, fbstp a) #define FCHS CHOICE(fchs, fchs, fchs) #define FCLEX CHOICE(fclex, wait; fnclex, wait; fclex) #define FNCLEX CHOICE(fnclex, fnclex, fclex) #define FCOM(a) CHOICE(fcom a, fcom a, fcom a) #define FCOM_D(a) CHOICE(fcoml a, fcoml a, fcomd a) #define FCOM_S(a) CHOICE(fcoms a, fcoms a, fcoms a) #define FCOMP(a) CHOICE(fcomp a, fcomp a, fcomp a) #define FCOMP_D(a) CHOICE(fcompl a, fcompl a, fcompd a) #define FCOMP_S(a) CHOICE(fcomps a, fcomps a, fcomps a) #define FCOMPP CHOICE(fcompp, fcompp, fcompp) #define FCOS CHOICE(fcos, fcos, fcos) #define FDECSTP CHOICE(fdecstp, fdecstp, fdecstp) #define FDIV_D(a) CHOICE(fdivl a, fdivl a, fdivd a) #define FDIV_S(a) CHOICE(fdivs a, fdivs a, fdivs a) #define FDIV2(a, b) CHOICE(fdiv ARG2(a,b), fdiv ARG2(a,b), fdiv ARG2(b,a)) #define FDIVP(a, b) CHOICE(fdivp ARG2(a,b), fdivp ARG2(a,b), fdivp ARG2(b,a)) #define FIDIV_L(a) CHOICE(fidivl a, fidivl a, fidivl a) #define FIDIV_W(a) CHOICE(fidiv a, fidivs a, fidivs a) #define FDIVR_D(a) CHOICE(fdivrl a, fdivrl a, fdivrd a) #define FDIVR_S(a) CHOICE(fdivrs a, fdivrs a, fdivrs a) #define FDIVR2(a, b) CHOICE(fdivr ARG2(a,b), fdivr ARG2(a,b), fdivr ARG2(b,a)) #define FDIVRP(a, b) CHOICE(fdivrp ARG2(a,b), fdivrp ARG2(a,b), fdivrp ARG2(b,a)) #define FIDIVR_L(a) CHOICE(fidivrl a, fidivrl a, fidivrl a) #define FIDIVR_W(a) CHOICE(fidivr a, fidivrs a, fidivrs a) #define FFREE(a) CHOICE(ffree a, ffree a, ffree a) #define FICOM_L(a) CHOICE(ficoml a, ficoml a, ficoml a) #define FICOM_W(a) CHOICE(ficom a, ficoms a, ficoms a) #define FICOMP_L(a) CHOICE(ficompl a, ficompl a, ficompl a) #define FICOMP_W(a) CHOICE(ficomp a, ficomps a, ficomps a) #define FILD_Q(a) CHOICE(fildll a, fildq a, fildq a) #define FILD_L(a) CHOICE(fildl a, fildl a, fildl a) #define FILD_W(a) CHOICE(fild a, filds a, filds a) #define FINCSTP CHOICE(fincstp, fincstp, fincstp) #define FINIT CHOICE(finit, wait; fninit, wait; finit) #define FNINIT CHOICE(fninit, fninit, finit) #define FIST_L(a) CHOICE(fistl a, fistl a, fistl a) #define FIST_W(a) CHOICE(fist a, fists a, fists a) #define FISTP_Q(a) CHOICE(fistpll a, fistpq a, fistpq a) #define FISTP_L(a) CHOICE(fistpl a, fistpl a, fistpl a) #define FISTP_W(a) CHOICE(fistp a, fistps a, fistps a) #define FLD_X(a) CHOICE(fldt a, fldt a, fldx a) /* 80 bit data type! */ #define FLD_D(a) CHOICE(fldl a, fldl a, fldd a) #define FLD_S(a) CHOICE(flds a, flds a, flds a) #define FLD1 CHOICE(fld1, fld1, fld1) #define FLDL2T CHOICE(fldl2t, fldl2t, fldl2t) #define FLDL2E CHOICE(fldl2e, fldl2e, fldl2e) #define FLDPI CHOICE(fldpi, fldpi, fldpi) #define FLDLG2 CHOICE(fldlg2, fldlg2, fldlg2) #define FLDLN2 CHOICE(fldln2, fldln2, fldln2) #define FLDZ CHOICE(fldz, fldz, fldz) #define FLDCW(a) CHOICE(fldcw a, fldcw a, fldcw a) #define FLDENV(a) CHOICE(fldenv a, fldenv a, fldenv a) #define FMUL_S(a) CHOICE(fmuls a, fmuls a, fmuls a) #define FMUL_D(a) CHOICE(fmull a, fmull a, fmuld a) #define FMUL2(a, b) CHOICE(fmul ARG2(a,b), fmul ARG2(a,b), fmul ARG2(b,a)) #define FMULP(a, b) CHOICE(fmulp ARG2(a,b), fmulp ARG2(a,b), fmulp ARG2(b,a)) #define FIMUL_L(a) CHOICE(fimull a, fimull a, fimull a) #define FIMUL_W(a) CHOICE(fimul a, fimuls a, fimuls a) #define FNOP CHOICE(fnop, fnop, fnop) #define FPATAN CHOICE(fpatan, fpatan, fpatan) #define FPREM CHOICE(fprem, fprem, fprem) #define FPREM1 CHOICE(fprem1, fprem1, fprem1) #define FPTAN CHOICE(fptan, fptan, fptan) #define FRNDINT CHOICE(frndint, frndint, frndint) #define FRSTOR(a) CHOICE(frstor a, frstor a, frstor a) #define FSAVE(a) CHOICE(fsave a, wait; fnsave a, wait; fsave a) #define FNSAVE(a) CHOICE(fnsave a, fnsave a, fsave a) #define FSCALE CHOICE(fscale, fscale, fscale) #define FSIN CHOICE(fsin, fsin, fsin) #define FSINCOS CHOICE(fsincos, fsincos, fsincos) #define FSQRT CHOICE(fsqrt, fsqrt, fsqrt) #define FST_D(a) CHOICE(fstl a, fstl a, fstd a) #define FST_S(a) CHOICE(fsts a, fsts a, fsts a) #define FSTP_X(a) CHOICE(fstpt a, fstpt a, fstpx a) #define FSTP_D(a) CHOICE(fstpl a, fstpl a, fstpd a) #define FSTP_S(a) CHOICE(fstps a, fstps a, fstps a) #define FSTP(a) CHOICE(fstp a, fstp a, fstp a) #define FSTCW(a) CHOICE(fstcw a, wait; fnstcw a, wait; fstcw a) #define FNSTCW(a) CHOICE(fnstcw a, fnstcw a, fstcw a) #define FSTENV(a) CHOICE(fstenv a, wait; fnstenv a, fstenv a) #define FNSTENV(a) CHOICE(fnstenv a, fnstenv a, fstenv a) #define FSTSW(a) CHOICE(fstsw a, wait; fnstsw a, wait; fstsw a) #define FNSTSW(a) CHOICE(fnstsw a, fnstsw a, fstsw a) #define FSUB_S(a) CHOICE(fsubs a, fsubs a, fsubs a) #define FSUB_D(a) CHOICE(fsubl a, fsubl a, fsubd a) #define FSUB2(a, b) CHOICE(fsub ARG2(a,b), fsub ARG2(a,b), fsub ARG2(b,a)) #define FSUBP(a, b) CHOICE(fsubp ARG2(a,b), fsubp ARG2(a,b), fsubp ARG2(b,a)) #define FISUB_L(a) CHOICE(fisubl a, fisubl a, fisubl a) #define FISUB_W(a) CHOICE(fisub a, fisubs a, fisubs a) #define FSUBR_S(a) CHOICE(fsubrs a, fsubrs a, fsubrs a) #define FSUBR_D(a) CHOICE(fsubrl a, fsubrl a, fsubrd a) #define FSUBR2(a, b) CHOICE(fsubr ARG2(a,b), fsubr ARG2(a,b), fsubr ARG2(b,a)) #define FSUBRP(a, b) CHOICE(fsubrp ARG2(a,b), fsubrp ARG2(a,b), fsubrp ARG2(b,a)) #define FISUBR_L(a) CHOICE(fisubrl a, fisubrl a, fisubrl a) #define FISUBR_W(a) CHOICE(fisubr a, fisubrs a, fisubrs a) #define FTST CHOICE(ftst, ftst, ftst) #define FUCOM(a) CHOICE(fucom a, fucom a, fucom a) #define FUCOMP(a) CHOICE(fucomp a, fucomp a, fucomp a) #define FUCOMPP CHOICE(fucompp, fucompp, fucompp) #define FWAIT CHOICE(wait, wait, wait) #define FXAM CHOICE(fxam, fxam, fxam) #define FXCH(a) CHOICE(fxch a, fxch a, fxch a) #define FXTRACT CHOICE(fxtract, fxtract, fxtract) #define FYL2X CHOICE(fyl2x, fyl2x, fyl2x) #define FYL2XP1 CHOICE(fyl2xp1, fyl2xp1, fyl2xp1) /* New instructions */ #define CPUID CHOICE(D_BYTE ARG2(15, 162), cpuid, D_BYTE ARG2(15, 162)) #define RDTSC CHOICE(D_BYTE ARG2(15, 49), rdtsc, D_BYTE ARG2(15, 49)) #else /* NASM_ASSEMBLER || MASM_ASSEMBLER is defined */ /****************************************/ /* */ /* Intel style assemblers. */ /* (NASM and MASM) */ /* */ /****************************************/ #define P_EAX EAX #define L_EAX EAX #define W_AX AX #define B_AH AH #define B_AL AL #define P_EBX EBX #define L_EBX EBX #define W_BX BX #define B_BH BH #define B_BL BL #define P_ECX ECX #define L_ECX ECX #define W_CX CX #define B_CH CH #define B_CL CL #define P_EDX EDX #define L_EDX EDX #define W_DX DX #define B_DH DH #define B_DL DL #define P_EBP EBP #define L_EBP EBP #define W_BP BP #define P_ESI ESI #define L_ESI ESI #define W_SI SI #define P_EDI EDI #define L_EDI EDI #define W_DI DI #define P_ESP ESP #define L_ESP ESP #define W_SP SP #define W_CS CS #define W_SS SS #define W_DS DS #define W_ES ES #define W_FS FS #define W_GS GS #define X_ST ST #define D_ST ST #define L_ST ST #define P_MM0 mm0 #define P_MM1 mm1 #define P_MM2 mm2 #define P_MM3 mm3 #define P_MM4 mm4 #define P_MM5 mm5 #define P_MM6 mm6 #define P_MM7 mm7 #define P_XMM0 xmm0 #define P_XMM1 xmm1 #define P_XMM2 xmm2 #define P_XMM3 xmm3 #define P_XMM4 xmm4 #define P_XMM5 xmm5 #define P_XMM6 xmm6 #define P_XMM7 xmm7 #if defined(NASM_ASSEMBLER) #define ST(n) st ## n #define TBYTE_PTR tword #define QWORD_PTR qword #define DWORD_PTR dword #define WORD_PTR word #define BYTE_PTR byte #define OFFSET #define GLOBL GLOBAL #define ALIGNTEXT32 ALIGN 32 #define ALIGNTEXT16 ALIGN 16 #define ALIGNTEXT8 ALIGN 8 #define ALIGNTEXT4 ALIGN 4 #define ALIGNTEXT2 ALIGN 2 #define ALIGNTEXT32ifNOP ALIGN 32 #define ALIGNTEXT16ifNOP ALIGN 16 #define ALIGNTEXT8ifNOP ALIGN 8 #define ALIGNTEXT4ifNOP ALIGN 4 #define ALIGNDATA32 ALIGN 32 #define ALIGNDATA16 ALIGN 16 #define ALIGNDATA8 ALIGN 8 #define ALIGNDATA4 ALIGN 4 #define ALIGNDATA2 ALIGN 2 #define FILE(s) #define STRING(s) db s #define D_LONG dd #define D_WORD dw #define D_BYTE db /* #define SPACE */ /* #define COMM */ #if defined(__WATCOMC__) SECTION _TEXT public align=16 class=CODE use32 flat SECTION _DATA public align=16 class=DATA use32 flat #define SEG_TEXT SECTION _TEXT #define SEG_DATA SECTION _DATA #define SEG_BSS SECTION .bss #else #define SEG_DATA SECTION .data #define SEG_TEXT SECTION .text #define SEG_BSS SECTION .bss #endif #define D_SPACE(n) db n REP 0 #define AS_BEGIN #define NEAR near /* Jcc's should be handled better than this... */ #else /* MASM */ #define TBYTE_PTR tbyte ptr #define QWORD_PTR qword ptr #define DWORD_PTR dword ptr #define WORD_PTR word ptr #define BYTE_PTR byte ptr #define OFFSET offset #define GLOBL GLOBAL #define ALIGNTEXT32 ALIGN 32 #define ALIGNTEXT16 ALIGN 16 #define ALIGNTEXT8 ALIGN 8 #define ALIGNTEXT4 ALIGN 4 #define ALIGNTEXT2 ALIGN 2 #define ALIGNTEXT32ifNOP ALIGN 32 #define ALIGNTEXT16ifNOP ALIGN 16 #define ALIGNTEXT8ifNOP ALIGN 8 #define ALIGNTEXT4ifNOP ALIGN 4 #define ALIGNDATA32 ALIGN 32 #define ALIGNDATA16 ALIGN 16 #define ALIGNDATA8 ALIGN 8 #define ALIGNDATA4 ALIGN 4 #define ALIGNDATA2 ALIGN 2 #define FILE(s) #define STRING(s) db s #define D_LONG dd #define D_WORD dw #define D_BYTE db /* #define SPACE */ /* #define COMM */ #define SEG_DATA .DATA #define SEG_TEXT .CODE #define SEG_BSS .DATA #define D_SPACE(n) db n REP 0 #define AS_BEGIN #define NEAR #endif #if defined(Lynx) || (defined(SYSV) || defined(SVR4)) \ || (defined(linux) || defined(__OS2ELF__)) && defined(__ELF__) \ || defined(__FreeBSD__) && __FreeBSD__ >= 3 #define GLNAME(a) a #else #define GLNAME(a) _ ## a #endif /* * Addressing Modes */ /* Immediate Mode */ #define P_ADDR(a) OFFSET a #define X_ADDR(a) OFFSET a #define D_ADDR(a) OFFSET a #define L_ADDR(a) OFFSET a #define W_ADDR(a) OFFSET a #define B_ADDR(a) OFFSET a #define P_CONST(a) a #define X_CONST(a) a #define D_CONST(a) a #define L_CONST(a) a #define W_CONST(a) a #define B_CONST(a) a /* Indirect Mode */ #define P_CONTENT(a) a #define X_CONTENT(a) TBYTE_PTR a #define D_CONTENT(a) QWORD_PTR a #define L_CONTENT(a) DWORD_PTR a #define W_CONTENT(a) WORD_PTR a #define B_CONTENT(a) BYTE_PTR a /* Register a indirect */ #define P_REGIND(a) [a] #define X_REGIND(a) TBYTE_PTR [a] #define D_REGIND(a) QWORD_PTR [a] #define L_REGIND(a) DWORD_PTR [a] #define W_REGIND(a) WORD_PTR [a] #define B_REGIND(a) BYTE_PTR [a] /* Register b indirect plus displacement a */ #define P_REGOFF(a, b) [b + a] #define X_REGOFF(a, b) TBYTE_PTR [b + a] #define D_REGOFF(a, b) QWORD_PTR [b + a] #define L_REGOFF(a, b) DWORD_PTR [b + a] #define W_REGOFF(a, b) WORD_PTR [b + a] #define B_REGOFF(a, b) BYTE_PTR [b + a] /* Reg indirect Base + Index + Displacement - this is mainly for 16-bit mode * which has no scaling */ #define P_REGBID(b, i, d) [b + i + d] #define X_REGBID(b, i, d) TBYTE_PTR [b + i + d] #define D_REGBID(b, i, d) QWORD_PTR [b + i + d] #define L_REGBID(b, i, d) DWORD_PTR [b + i + d] #define W_REGBID(b, i, d) WORD_PTR [b + i + d] #define B_REGBID(b, i, d) BYTE_PTR [b + i + d] /* Reg indirect Base + (Index * Scale) + Displacement */ #define P_REGBISD(b, i, s, d) [b + i * s + d] #define X_REGBISD(b, i, s, d) TBYTE_PTR [b + i * s + d] #define D_REGBISD(b, i, s, d) QWORD_PTR [b + i * s + d] #define L_REGBISD(b, i, s, d) DWORD_PTR [b + i * s + d] #define W_REGBISD(b, i, s, d) WORD_PTR [b + i * s + d] #define B_REGBISD(b, i, s, d) BYTE_PTR [b + i * s + d] /* Displaced Scaled Index: */ #define P_REGDIS(d, i, s) [i * s + d] #define X_REGDIS(d, i, s) TBYTE_PTR [i * s + d] #define D_REGDIS(d, i, s) QWORD_PTR [i * s + d] #define L_REGDIS(d, i, s) DWORD_PTR [i * s + d] #define W_REGDIS(d, i, s) WORD_PTR [i * s + d] #define B_REGDIS(d, i, s) BYTE_PTR [i * s + d] /* Indexed Base: */ #define P_REGBI(b, i) [b + i] #define X_REGBI(b, i) TBYTE_PTR [b + i] #define D_REGBI(b, i) QWORD_PTR [b + i] #define L_REGBI(b, i) DWORD_PTR [b + i] #define W_REGBI(b, i) WORD_PTR [b + i] #define B_REGBI(b, i) BYTE_PTR [b + i] /* Displaced Base: */ #define P_REGDB(d, b) [b + d] #define X_REGDB(d, b) TBYTE_PTR [b + d] #define D_REGDB(d, b) QWORD_PTR [b + d] #define L_REGDB(d, b) DWORD_PTR [b + d] #define W_REGDB(d, b) WORD_PTR [b + d] #define B_REGDB(d, b) BYTE_PTR [b + d] /* Variable indirect: */ #define VARINDIRECT(var) var /* Use register contents as jump/call target: */ #define CODEPTR(reg) reg /* * Redefine assembler commands */ #define P_(a) P_ ## a #define X_(a) X_ ## a #define D_(a) D_ ## a #define S_(a) L_ ## a #define L_(a) L_ ## a #define W_(a) W_ ## a #define B_(a) B_ ## a #define AAA aaa #define AAD aad #define AAM aam #define AAS aas #define ADC_L(a, b) adc L_(b), L_(a) #define ADC_W(a, b) adc W_(b), W_(a) #define ADC_B(a, b) adc B_(b), B_(a) #define ADD_L(a, b) add L_(b), L_(a) #define ADD_W(a, b) add W_(b), W_(a) #define ADD_B(a, b) add B_(b), B_(a) #define AND_L(a, b) and L_(b), L_(a) #define AND_W(a, b) and W_(b), W_(a) #define AND_B(a, b) and B_(b), B_(a) #define ARPL(a,b) arpl W_(b), a #define BOUND_L(a, b) bound L_(b), L_(a) #define BOUND_W(a, b) bound W_(b), W_(a) #define BSF_L(a, b) bsf L_(b), L_(a) #define BSF_W(a, b) bsf W_(b), W_(a) #define BSR_L(a, b) bsr L_(b), L_(a) #define BSR_W(a, b) bsr W_(b), W_(a) #define BT_L(a, b) bt L_(b), L_(a) #define BT_W(a, b) bt W_(b), W_(a) #define BTC_L(a, b) btc L_(b), L_(a) #define BTC_W(a, b) btc W_(b), W_(a) #define BTR_L(a, b) btr L_(b), L_(a) #define BTR_W(a, b) btr W_(b), W_(a) #define BTS_L(a, b) bts L_(b), L_(a) #define BTS_W(a, b) bts W_(b), W_(a) #define CALL(a) call a #define CALLF(s,a) call far s:a #define CBW cbw #define CWDE cwde #define CLC clc #define CLD cld #define CLI cli #define CLTS clts #define CMC cmc #define CMP_L(a, b) cmp L_(b), L_(a) #define CMP_W(a, b) cmp W_(b), W_(a) #define CMP_B(a, b) cmp B_(b), B_(a) #define CMPS_L cmpsd #define CMPS_W cmpsw #define CMPS_B cmpsb #define CWD cwd #define CDQ cdq #define DAA daa #define DAS das #define DEC_L(a) dec L_(a) #define DEC_W(a) dec W_(a) #define DEC_B(a) dec B_(a) #define DIV_L(a) div L_(a) #define DIV_W(a) div W_(a) #define DIV_B(a) div B_(a) #define ENTER(a,b) enter b, a #define HLT hlt #define IDIV_L(a) idiv L_(a) #define IDIV_W(a) idiv W_(a) #define IDIV_B(a) idiv B_(a) #define IMUL_L(a, b) imul L_(b), L_(a) #define IMUL_W(a, b) imul W_(b), W_(a) #define IMUL_B(a) imul B_(a) #define IN_L in EAX, DX #define IN_W in AX, DX #define IN_B in AL, DX #define IN1_L(a) in1 L_(a) #define IN1_W(a) in1 W_(a) #define IN1_B(a) in1 B_(a) #define INC_L(a) inc L_(a) #define INC_W(a) inc W_(a) #define INC_B(a) inc B_(a) #define INS_L ins #define INS_W ins #define INS_B ins #define INT(a) int B_(a) #define INT3 int3 #define INTO into #define IRET iret #define IRETD iretd #define JA(a) ja NEAR a #define JAE(a) jae NEAR a #define JB(a) jb NEAR a #define JBE(a) jbe NEAR a #define JC(a) jc NEAR a #define JE(a) je NEAR a #define JG(a) jg NEAR a #define JGE(a) jge NEAR a #define JL(a) jl NEAR a #define JLE(a) jle NEAR a #define JNA(a) jna NEAR a #define JNAE(a) jnae NEAR a #define JNB(a) jnb NEAR a #define JNBE(a) jnbe NEAR a #define JNC(a) jnc NEAR a #define JNE(a) jne NEAR a #define JNG(a) jng NEAR a #define JNGE(a) jnge NEAR a #define JNL(a) jnl NEAR a #define JNLE(a) jnle NEAR a #define JNO(a) jno NEAR a #define JNP(a) jnp NEAR a #define JNS(a) jns NEAR a #define JNZ(a) jnz NEAR a #define JO(a) jo NEAR a #define JP(a) jp NEAR a #define JPE(a) jpe NEAR a #define JPO(a) jpo NEAR a #define JS(a) js NEAR a #define JZ(a) jz NEAR a #define JMP(a) jmp a #define JMPF(s,a) jmpf #define LAHF lahf #define LAR(a, b) lar b, a #define LEA_L(a, b) lea P_(b), P_(a) #define LEA_W(a, b) lea P_(b), P_(a) #define LEAVE leave #define LGDT(a) lgdt a #define LIDT(a) lidt a #define LDS(a, b) lds b, a #define LES(a, b) les b, a #define LFS(a, b) lfs b, a #define LGS(a, b) lgs b, a #define LSS(a, b) lss b, a #define LLDT(a) lldt a #define LMSW(a) lmsw a #define LOCK lock #define LODS_L lodsd #define LODS_W lodsw #define LODS_B lodsb #define LOOP(a) loop a #define LOOPE(a) loope a #define LOOPZ(a) loopz a #define LOOPNE(a) loopne a #define LOOPNZ(a) loopnz a #define LSL(a, b) lsl b, a #define LTR(a) ltr a #define MOV_SR(a, b) mov S_(b), S_(a) #define MOV_L(a, b) mov L_(b), L_(a) #define MOV_W(a, b) mov W_(b), W_(a) #define MOV_B(a, b) mov B_(b), B_(a) #define MOVS_L movsd #define MOVS_W movsw #define MOVS_B movsb #define MOVSX_BL(a, b) movsx B_(b), B_(a) #define MOVSX_BW(a, b) movsx B_(b), B_(a) #define MOVSX_WL(a, b) movsx W_(b), W_(a) #define MOVZX_BL(a, b) movzx B_(b), B_(a) #define MOVZX_BW(a, b) movzx B_(b), B_(a) #define MOVZX_WL(a, b) movzx W_(b), W_(a) #define MUL_L(a) mul L_(a) #define MUL_W(a) mul W_(a) #define MUL_B(a) mul B_(a) #define NEG_L(a) neg L_(a) #define NEG_W(a) neg W_(a) #define NEG_B(a) neg B_(a) #define NOP nop #define NOT_L(a) not L_(a) #define NOT_W(a) not W_(a) #define NOT_B(a) not B_(a) #define OR_L(a,b) or L_(b), L_(a) #define OR_W(a,b) or W_(b), W_(a) #define OR_B(a,b) or B_(b), B_(a) #define OUT_L out DX, EAX #define OUT_W out DX, AX #define OUT_B out DX, AL #define OUT1_L(a) out1 L_(a) #define OUT1_W(a) out1 W_(a) #define OUT1_B(a) out1 B_(a) #define OUTS_L outsd #define OUTS_W outsw #define OUTS_B outsb #define POP_SR(a) pop S_(a) #define POP_L(a) pop L_(a) #define POP_W(a) pop W_(a) #define POPA_L popad #define POPA_W popa #define POPF_L popfd #define POPF_W popf #define PUSH_SR(a) push S_(a) #define PUSH_L(a) push L_(a) #define PUSH_W(a) push W_(a) #define PUSH_B(a) push B_(a) #define PUSHA_L pushad #define PUSHA_W pusha #define PUSHF_L pushfd #define PUSHF_W pushf #define RCL_L(a, b) rcl L_(b), L_(a) #define RCL_W(a, b) rcl W_(b), W_(a) #define RCL_B(a, b) rcl B_(b), B_(a) #define RCR_L(a, b) rcr L_(b), L_(a) #define RCR_W(a, b) rcr W_(b), W_(a) #define RCR_B(a, b) rcr B_(b), B_(a) #define ROL_L(a, b) rol L_(b), L_(a) #define ROL_W(a, b) rol W_(b), W_(a) #define ROL_B(a, b) rol B_(b), B_(a) #define ROR_L(a, b) ror L_(b), L_(a) #define ROR_W(a, b) ror W_(b), W_(a) #define ROR_B(a, b) ror B_(b), B_(a) #define REP rep #define REPE repe #define REPNE repne #define REPNZ REPNE #define REPZ REPE #define RET ret #define SAHF sahf #define SAL_L(a, b) sal L_(b), L_(a) #define SAL_W(a, b) sal W_(b), W_(a) #define SAL_B(a, b) sal B_(b), B_(a) #define SAR_L(a, b) sar L_(b), L_(a) #define SAR_W(a, b) sar W_(b), W_(a) #define SAR_B(a, b) sar B_(b), B_(a) #define SBB_L(a, b) sbb L_(b), L_(a) #define SBB_W(a, b) sbb W_(b), W_(a) #define SBB_B(a, b) sbb B_(b), B_(a) #define SCAS_L scas #define SCAS_W scas #define SCAS_B scas #define SETA(a) seta a #define SETAE(a) setae a #define SETB(a) setb a #define SETBE(a) setbe a #define SETC(a) setc a #define SETE(a) sete a #define SETG(a) setg a #define SETGE(a) setge a #define SETL(a) setl a #define SETLE(a) setle a #define SETNA(a) setna a #define SETNAE(a) setnae a #define SETNB(a) setnb a #define SETNBE(a) setnbe a #define SETNC(a) setnc a #define SETNE(a) setne a #define SETNG(a) setng a #define SETNGE(a) setnge a #define SETNL(a) setnl a #define SETNLE(a) setnle a #define SETNO(a) setno a #define SETNP(a) setnp a #define SETNS(a) setns a #define SETNZ(a) setnz a #define SETO(a) seto a #define SETP(a) setp a #define SETPE(a) setpe a #define SETPO(a) setpo a #define SETS(a) sets a #define SETZ(a) setz a #define SGDT(a) sgdt a #define SIDT(a) sidt a #define SHL_L(a, b) shl L_(b), L_(a) #define SHL_W(a, b) shl W_(b), W_(a) #define SHL_B(a, b) shl B_(b), B_(a) #define SHLD_L(a,b,c) shld #define SHLD2_L(a,b) shld L_(b), L_(a) #define SHLD_W(a,b,c) shld #define SHLD2_W(a,b) shld W_(b), W_(a) #define SHR_L(a, b) shr L_(b), L_(a) #define SHR_W(a, b) shr W_(b), W_(a) #define SHR_B(a, b) shr B_(b), B_(a) #define SHRD_L(a,b,c) shrd #define SHRD2_L(a,b) shrd L_(b), L_(a) #define SHRD_W(a,b,c) shrd #define SHRD2_W(a,b) shrd W_(b), W_(a) #define SLDT(a) sldt a #define SMSW(a) smsw a #define STC stc #define STD std #define STI sti #define STOS_L stos #define STOS_W stos #define STOS_B stos #define STR(a) str a #define SUB_L(a, b) sub L_(b), L_(a) #define SUB_W(a, b) sub W_(b), W_(a) #define SUB_B(a, b) sub B_(b), B_(a) #define TEST_L(a, b) test L_(b), L_(a) #define TEST_W(a, b) test W_(b), W_(a) #define TEST_B(a, b) test B_(b), B_(a) #define VERR(a) verr a #define VERW(a) verw a #define WAIT wait #define XCHG_L(a, b) xchg L_(b), L_(a) #define XCHG_W(a, b) xchg W_(b), W_(a) #define XCHG_B(a, b) xchg B_(b), B_(a) #define XLAT xlat #define XOR_L(a, b) xor L_(b), L_(a) #define XOR_W(a, b) xor W_(b), W_(a) #define XOR_B(a, b) xor B_(b), B_(a) #define F2XM1 f2xm1 #define FABS fabs #define FADD_D(a) fadd D_(a) #define FADD_S(a) fadd S_(a) #define FADD2(a, b) fadd b, a #define FADDP(a, b) faddp b, a #define FIADD_L(a) fiadd L_(a) #define FIADD_W(a) fiadd W_(a) #define FBLD(a) fbld a #define FBSTP(a) fbstp a #define FCHS fchs #define FCLEX fclex #define FNCLEX fnclex #define FCOM(a) fcom a #define FCOM_D(a) fcom D_(a) #define FCOM_S(a) fcom S_(a) #define FCOMP(a) fcomp a #define FCOMP_D(a) fcomp D_(a) #define FCOMP_S(a) fcomp S_(a) #define FCOMPP fcompp #define FCOS fcos #define FDECSTP fdecstp #define FDIV_D(a) fdiv D_(a) #define FDIV_S(a) fdiv S_(a) #define FDIV2(a, b) fdiv b, a #define FDIVP(a, b) fdivp b, a #define FIDIV_L(a) fidiv L_(a) #define FIDIV_W(a) fidiv W_(a) #define FDIVR_D(a) fdivr D_(a) #define FDIVR_S(a) fdivr S_(a) #define FDIVR2(a, b) fdivr b, a #define FDIVRP(a, b) fdivrp b, a #define FIDIVR_L(a) fidivr L_(a) #define FIDIVR_W(a) fidivr W_(a) #define FFREE(a) ffree a #define FICOM_L(a) ficom L_(a) #define FICOM_W(a) ficom W_(a) #define FICOMP_L(a) ficomp L_(a) #define FICOMP_W(a) ficomp W_(a) #define FILD_Q(a) fild D_(a) #define FILD_L(a) fild L_(a) #define FILD_W(a) fild W_(a) #define FINCSTP fincstp #define FINIT finit #define FNINIT fninit #define FIST_L(a) fist L_(a) #define FIST_W(a) fist W_(a) #define FISTP_Q(a) fistp D_(a) #define FISTP_L(a) fistp L_(a) #define FISTP_W(a) fistp W_(a) #define FLD_X(a) fld X_(a) #define FLD_D(a) fld D_(a) #define FLD_S(a) fld S_(a) #define FLD1 fld1 #define FLDL2T fldl2t #define FLDL2E fldl2e #define FLDPI fldpi #define FLDLG2 fldlg2 #define FLDLN2 fldln2 #define FLDZ fldz #define FLDCW(a) fldcw a #define FLDENV(a) fldenv a #define FMUL_S(a) fmul S_(a) #define FMUL_D(a) fmul D_(a) #define FMUL2(a, b) fmul b, a #define FMULP(a, b) fmulp b, a #define FIMUL_L(a) fimul L_(a) #define FIMUL_W(a) fimul W_(a) #define FNOP fnop #define FPATAN fpatan #define FPREM fprem #define FPREM1 fprem1 #define FPTAN fptan #define FRNDINT frndint #define FRSTOR(a) frstor a #define FSAVE(a) fsave a #define FNSAVE(a) fnsave a #define FSCALE fscale #define FSIN fsin #define FSINCOS fsincos #define FSQRT fsqrt #define FST_D(a) fst D_(a) #define FST_S(a) fst S_(a) #define FSTP_X(a) fstp X_(a) #define FSTP_D(a) fstp D_(a) #define FSTP_S(a) fstp S_(a) #define FSTP(a) fstp a #define FSTCW(a) fstcw a #define FNSTCW(a) fnstcw a #define FSTENV(a) fstenv a #define FNSTENV(a) fnstenv a #define FSTSW(a) fstsw a #define FNSTSW(a) fnstsw a #define FSUB_S(a) fsub S_(a) #define FSUB_D(a) fsub D_(a) #define FSUB2(a, b) fsub b, a #define FSUBP(a, b) fsubp b, a #define FISUB_L(a) fisub L_(a) #define FISUB_W(a) fisub W_(a) #define FSUBR_S(a) fsubr S_(a) #define FSUBR_D(a) fsubr D_(a) #define FSUBR2(a, b) fsubr b, a #define FSUBRP(a, b) fsubrp b, a #define FISUBR_L(a) fisubr L_(a) #define FISUBR_W(a) fisubr W_(a) #define FTST ftst #define FUCOM(a) fucom a #define FUCOMP(a) fucomp a #define FUCOMPP fucompp #define FWAIT fwait #define FXAM fxam #define FXCH(a) fxch a #define FXTRACT fxtract #define FYL2X fyl2x #define FYL2XP1 fyl2xp1 /* New instructions */ #define CPUID D_BYTE 15, 162 #define RDTSC D_BYTE 15, 49 #endif /* NASM_ASSEMBLER, MASM_ASSEMBLER */ /****************************************/ /* */ /* Extensions to x86 insn set - */ /* MMX, 3DNow! */ /* */ /****************************************/ #if defined(NASM_ASSEMBLER) || defined(MASM_ASSEMBLER) #define P_ARG1(a) P_ ## a #define P_ARG2(a, b) P_ ## b, P_ ## a #define P_ARG3(a, b, c) P_ ## c, P_ ## b, P_ ## a #else #define P_ARG1(a) a #define P_ARG2(a, b) a, b #define P_ARG3(a, b, c) a, b, c #endif /* MMX */ #define MOVD(a, b) movd P_ARG2(a, b) #define MOVQ(a, b) movq P_ARG2(a, b) #define PADDB(a, b) paddb P_ARG2(a, b) #define PADDW(a, b) paddw P_ARG2(a, b) #define PADDD(a, b) paddd P_ARG2(a, b) #define PADDSB(a, b) paddsb P_ARG2(a, b) #define PADDSW(a, b) paddsw P_ARG2(a, b) #define PADDUSB(a, b) paddusb P_ARG2(a, b) #define PADDUSW(a, b) paddusw P_ARG2(a, b) #define PSUBB(a, b) psubb P_ARG2(a, b) #define PSUBW(a, b) psubw P_ARG2(a, b) #define PSUBD(a, b) psubd P_ARG2(a, b) #define PSUBSB(a, b) psubsb P_ARG2(a, b) #define PSUBSW(a, b) psubsw P_ARG2(a, b) #define PSUBUSB(a, b) psubusb P_ARG2(a, b) #define PSUBUSW(a, b) psubusw P_ARG2(a, b) #define PCMPEQB(a, b) pcmpeqb P_ARG2(a, b) #define PCMPEQW(a, b) pcmpeqw P_ARG2(a, b) #define PCMPEQD(a, b) pcmpeqd P_ARG2(a, b) #define PCMPGTB(a, b) pcmpgtb P_ARG2(a, b) #define PCMPGTW(a, b) pcmpgtw P_ARG2(a, b) #define PCMPGTD(a, b) pcmpgtd P_ARG2(a, b) #define PMULHW(a, b) pmulhw P_ARG2(a, b) #define PMULLW(a, b) pmullw P_ARG2(a, b) #define PMADDWD(a, b) pmaddwd P_ARG2(a, b) #define PAND(a, b) pand P_ARG2(a, b) #define PANDN(a, b) pandn P_ARG2(a, b) #define POR(a, b) por P_ARG2(a, b) #define PXOR(a, b) pxor P_ARG2(a, b) #define PSRAW(a, b) psraw P_ARG2(a, b) #define PSRAD(a, b) psrad P_ARG2(a, b) #define PSRLW(a, b) psrlw P_ARG2(a, b) #define PSRLD(a, b) psrld P_ARG2(a, b) #define PSRLQ(a, b) psrlq P_ARG2(a, b) #define PSLLW(a, b) psllw P_ARG2(a, b) #define PSLLD(a, b) pslld P_ARG2(a, b) #define PSLLQ(a, b) psllq P_ARG2(a, b) #define PACKSSWB(a, b) packsswb P_ARG2(a, b) #define PACKSSDW(a, b) packssdw P_ARG2(a, b) #define PACKUSWB(a, b) packuswb P_ARG2(a, b) #define PUNPCKHBW(a, b) punpckhbw P_ARG2(a, b) #define PUNPCKHWD(a, b) punpckhwd P_ARG2(a, b) #define PUNPCKHDQ(a, b) punpckhdq P_ARG2(a, b) #define PUNPCKLBW(a, b) punpcklbw P_ARG2(a, b) #define PUNPCKLWD(a, b) punpcklwd P_ARG2(a, b) #define PUNPCKLDQ(a, b) punpckldq P_ARG2(a, b) #define EMMS emms /* AMD 3DNow! */ #define PAVGUSB(a, b) pavgusb P_ARG2(a, b) #define PFADD(a, b) pfadd P_ARG2(a, b) #define PFSUB(a, b) pfsub P_ARG2(a, b) #define PFSUBR(a, b) pfsubr P_ARG2(a, b) #define PFACC(a, b) pfacc P_ARG2(a, b) #define PFCMPGE(a, b) pfcmpge P_ARG2(a, b) #define PFCMPGT(a, b) pfcmpgt P_ARG2(a, b) #define PFCMPEQ(a, b) pfcmpeq P_ARG2(a, b) #define PFMIN(a, b) pfmin P_ARG2(a, b) #define PFMAX(a, b) pfmax P_ARG2(a, b) #define PI2FD(a, b) pi2fd P_ARG2(a, b) #define PF2ID(a, b) pf2id P_ARG2(a, b) #define PFRCP(a, b) pfrcp P_ARG2(a, b) #define PFRSQRT(a, b) pfrsqrt P_ARG2(a, b) #define PFMUL(a, b) pfmul P_ARG2(a, b) #define PFRCPIT1(a, b) pfrcpit1 P_ARG2(a, b) #define PFRSQIT1(a, b) pfrsqit1 P_ARG2(a, b) #define PFRCPIT2(a, b) pfrcpit2 P_ARG2(a, b) #define PMULHRW(a, b) pmulhrw P_ARG2(a, b) #define FEMMS femms #define PREFETCH(a) prefetch P_ARG1(a) #define PREFETCHW(a) prefetchw P_ARG1(a) /* Intel SSE */ #define ADDPS(a, b) addps P_ARG2(a, b) #define ADDSS(a, b) addss P_ARG2(a, b) #define ANDNPS(a, b) andnps P_ARG2(a, b) #define ANDPS(a, b) andps P_ARG2(a, b) /* NASM only knows the pseudo ops for these. #define CMPPS(a, b, c) cmpps P_ARG3(a, b, c) #define CMPSS(a, b, c) cmpss P_ARG3(a, b, c) */ #define CMPEQPS(a, b) cmpeqps P_ARG2(a, b) #define CMPLTPS(a, b) cmpltps P_ARG2(a, b) #define CMPLEPS(a, b) cmpleps P_ARG2(a, b) #define CMPUNORDPS(a, b) cmpunordps P_ARG2(a, b) #define CMPNEQPS(a, b) cmpneqps P_ARG2(a, b) #define CMPNLTPS(a, b) cmpnltps P_ARG2(a, b) #define CMPNLEPS(a, b) cmpnleps P_ARG2(a, b) #define CMPORDPS(a, b) cmpordps P_ARG2(a, b) #define CMPEQSS(a, b) cmpeqss P_ARG2(a, b) #define CMPLTSS(a, b) cmpltss P_ARG2(a, b) #define CMPLESS(a, b) cmpless P_ARG2(a, b) #define CMPUNORDSS(a, b) cmpunordss P_ARG2(a, b) #define CMPNEQSS(a, b) cmpneqss P_ARG2(a, b) #define CMPNLTSS(a, b) cmpnltss P_ARG2(a, b) #define CMPNLESS(a, b) cmpnless P_ARG2(a, b) #define CMPORDSS(a, b) cmpordss P_ARG2(a, b) #define COMISS(a, b) comiss P_ARG2(a, b) #define CVTPI2PS(a, b) cvtpi2ps P_ARG2(a, b) #define CVTPS2PI(a, b) cvtps2pi P_ARG2(a, b) #define CVTSI2SS(a, b) cvtsi2ss P_ARG2(a, b) #define CVTSS2SI(a, b) cvtss2si P_ARG2(a, b) #define CVTTPS2PI(a, b) cvttps2pi P_ARG2(a, b) #define CVTTSS2SI(a, b) cvttss2si P_ARG2(a, b) #define DIVPS(a, b) divps P_ARG2(a, b) #define DIVSS(a, b) divss P_ARG2(a, b) #define FXRSTOR(a) fxrstor P_ARG1(a) #define FXSAVE(a) fxsave P_ARG1(a) #define LDMXCSR(a) ldmxcsr P_ARG1(a) #define MAXPS(a, b) maxps P_ARG2(a, b) #define MAXSS(a, b) maxss P_ARG2(a, b) #define MINPS(a, b) minps P_ARG2(a, b) #define MINSS(a, b) minss P_ARG2(a, b) #define MOVAPS(a, b) movaps P_ARG2(a, b) #define MOVHLPS(a, b) movhlps P_ARG2(a, b) #define MOVHPS(a, b) movhps P_ARG2(a, b) #define MOVLHPS(a, b) movlhps P_ARG2(a, b) #define MOVLPS(a, b) movlps P_ARG2(a, b) #define MOVMSKPS(a, b) movmskps P_ARG2(a, b) #define MOVSS(a, b) movss P_ARG2(a, b) #define MOVUPS(a, b) movups P_ARG2(a, b) #define MULPS(a, b) mulps P_ARG2(a, b) #define MULSS(a, b) mulss P_ARG2(a, b) #define ORPS(a, b) orps P_ARG2(a, b) #define RCPPS(a, b) rcpps P_ARG2(a, b) #define RCPSS(a, b) rcpss P_ARG2(a, b) #define RSQRTPS(a, b) rsqrtps P_ARG2(a, b) #define RSQRTSS(a, b) rsqrtss P_ARG2(a, b) #define SHUFPS(a, b, c) shufps P_ARG3(a, b, c) #define SQRTPS(a, b) sqrtps P_ARG2(a, b) #define SQRTSS(a, b) sqrtss P_ARG2(a, b) #define STMXCSR(a) stmxcsr P_ARG1(a) #define SUBPS(a, b) subps P_ARG2(a, b) #define UCOMISS(a, b) ucomiss P_ARG2(a, b) #define UNPCKHPS(a, b) unpckhps P_ARG2(a, b) #define UNPCKLPS(a, b) unpcklps P_ARG2(a, b) #define XORPS(a, b) xorps P_ARG2(a, b) #endif /* __ASSYNTAX_H__ */