WebSVN – Kolibri OS – Diff – /contrib/sdk/sources/Mesa/src/mesa/x86/assyntax.h


#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))
 
/* Default to ATT_ASSEMBLER when SVR4 or SYSV are defined */
#if (defined(SVR4) || defined(SYSV)) && !defined(GNU_ASSEMBLER)
#define ATT_ASSEMBLER
#endif
 
#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
#define CONCAT3(x, y, z)	x ## y ## z
#else
#define CONCAT(x, y)		x/**/y
#define CONCAT3(x, y, z)	x/**/y/**/z
#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)
#ifdef GNU_ASSEMBLER
#define ST0		%st(0)
#else
#define ST0		%st
#endif
/* 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 */
 
 
 
 
 
#define GLNAME(a)   CONCAT(_,a)
 
 
 
	/****************************************/
	/*					*/
	/*	Select the various choices	*/
	/*					*/
	/****************************************/
 
 
/* Redefine assembler directives */
/*********************************/
#define GLOBL		CHOICE(.globl, .globl, .extern)
#define GLOBAL		GLOBL
#define EXTERN		GLOBL
#ifndef __AOUT__
#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)
#else
/* 'as -aout' on FreeBSD doesn't have .balign */
#define ALIGNTEXT32	CHOICE(.align 32, .align ARG2(5,0x90), .align 32)
#define ALIGNTEXT16	CHOICE(.align 16, .align ARG2(4,0x90), .align 16)
#define ALIGNTEXT8	CHOICE(.align 8, .align ARG2(3,0x90), .align 8)
#define ALIGNTEXT4	CHOICE(.align 4, .align ARG2(2,0x90), .align 4)
#define ALIGNTEXT2	CHOICE(.align 2, .align ARG2(1,0x90), .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, .align ARG2(5,0x90), /*can't do it*/)
#define ALIGNTEXT16ifNOP	CHOICE(.align 16, .align ARG2(4,0x90), /*can't do it*/)
#define ALIGNTEXT8ifNOP	CHOICE(.align 8, .align ARG2(3,0x90), /*can't do it*/)
#define ALIGNTEXT4ifNOP	CHOICE(.align 4, .align ARG2(2,0x90), /*can't do it*/)
#define ALIGNDATA32	CHOICE(.align 32, .align ARG2(5,0x0), .align 32)
#define ALIGNDATA16	CHOICE(.align 16, .align ARG2(4,0x0), .align 16)
#define ALIGNDATA8	CHOICE(.align 8, .align ARG2(3,0x0), .align 8)
#define ALIGNDATA4	CHOICE(.align 4, .align ARG2(2,0x0), .align 4)
#define ALIGNDATA2	CHOICE(.align 2, .align ARG2(1,0x0), .align 2)
#endif /* __AOUT__ */
#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), $a, a)
#define CONST(a)	CHOICE(CONCAT($,a), $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) */
#define REGBIS(b,i,s)	CHOICE((b,i,s), (b,i,s), (b)(i*s))
/* 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
 
#define CONCAT(x, y)		x ## y
#define CONCAT3(x, y, z)	x ## y ## z
 
#if defined(NASM_ASSEMBLER)
 
#define ST(n)		st ## n
#define ST0		st0
 
#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
 
/* Jcc's should be handled better than this... */
#define NEAR		near
 
#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
 
 
 
 
 
 
 
#define GLNAME(a)	CONCAT(_, a)
 
 
/*
 *	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 */
#ifdef NASM_ASSEMBLER
#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]
#else
#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
#endif
 
/* 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) */
#define P_REGBIS(b, i, s)	[b + i * s]
#define X_REGBIS(b, i, s)	TBYTE_PTR [b + i * s]
#define D_REGBIS(b, i, s)	QWORD_PTR [b + i * s]
#define L_REGBIS(b, i, s)	DWORD_PTR [b + i * s]
#define W_REGBIS(b, i, s)	WORD_PTR [b + i * s]
#define B_REGBIS(b, i, s)	BYTE_PTR [b + i * s]
 
/* 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)		P_(reg)
 
/*
 * Redefine assembler commands
 */
 
#define P_(a)			P_ ## a
#define X_(a)			X_ ## a
#define D_(a)			D_ ## a
#define SR_(a)			W_ ## 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 CPUID			cpuid
#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)		jmp far s:a
#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, P_(a)
#define LES(a, b)		les b, P_(a)
#define LFS(a, b)		lfs b, P_(a)
#define LGS(a, b)		lgs b, P_(a)
#define LSS(a, b)		lss b, P_(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 SR_(b), SR_(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 SR_(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 SR_(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 RDTSC			rdtsc
#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), B_(a)
#define SAL_W(a, b)		sal W_(b), B_(a)
#define SAL_B(a, b)		sal B_(b), B_(a)
#define SAR_L(a, b)		sar L_(b), B_(a)
#define SAR_W(a, b)		sar W_(b), B_(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), B_(a)
#define SHL_W(a, b)		shl W_(b), B_(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), B_(a)
#define SHR_W(a, b)		shr W_(b), B_(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			stosd
#define STOS_W			stosw
#define STOS_B			stosb
#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)
 
 
/* Floating Point Instructions */
#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
 
#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 MOVNTPS(a, b)		movntps P_ARG2(a, b)
#define MOVNTQ(a, b)		movntq 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)
 
#define PREFETCHNTA(a)		prefetchnta P_ARG1(a)
#define PREFETCHT0(a)		prefetcht0 P_ARG1(a)
#define PREFETCHT1(a)		prefetcht1 P_ARG1(a)
#define PREFETCHT2(a)		prefetcht2 P_ARG1(a)
#define SFENCE			sfence
 
/* Added by BrianP for FreeBSD (per David Dawes) */
#if !defined(NASM_ASSEMBLER) && !defined(MASM_ASSEMBLER) && !defined(__bsdi__)
#define LLBL(a)		CONCAT(.L,a)
#define LLBL2(a,b)	CONCAT3(.L,a,b)
#else
#define LLBL(a)		a
#define LLBL2(a,b)	CONCAT(a,b)
#endif
 
/* Segment overrides */
#define SEGCS		D_BYTE	46
#define SEGDS		D_BYTE	62
#define SEGES		D_BYTE	38
#define SEGFS		D_BYTE	100
#define SEGGS		D_BYTE	101
 
/* Temporary labels: valid until next non-local label */
#ifdef NASM_ASSEMBLER
#define TLBL(a)		CONCAT(.,a)
#else
#define TLBL(a)		CONCAT(a,$)
#endif
 
/* Hidden symbol visibility support.
 * If we build with gcc's -fvisibility=hidden flag, we'll need to change
 * the symbol visibility mode to 'default'.
 */
 
 
 
 
 
 
 
 
 
#define HIDDEN(x)
 
#endif /* __ASSYNTAX_H__ */
>
>

Rev 4358	Rev 5063
1	#ifndef __ASSYNTAX_H__	1	#ifndef __ASSYNTAX_H__
2	#define __ASSYNTAX_H__	2	#define __ASSYNTAX_H__
3		3
4	/*	4	/*
5	* Copyright 1992 Vrije Universiteit, The Netherlands	5	* Copyright 1992 Vrije Universiteit, The Netherlands
6	*	6	*
7	* Permission to use, copy, modify, and distribute this software and its	7	* Permission to use, copy, modify, and distribute this software and its
8	* documentation for any purpose and without fee is hereby granted, provided	8	* documentation for any purpose and without fee is hereby granted, provided
9	* that the above copyright notice appear in all copies and that both that	9	* that the above copyright notice appear in all copies and that both that
10	* copyright notice and this permission notice appear in supporting	10	* copyright notice and this permission notice appear in supporting
11	* documentation, and that the name of the Vrije Universiteit not be used in	11	* documentation, and that the name of the Vrije Universiteit not be used in
12	* advertising or publicity pertaining to distribution of the software without	12	* advertising or publicity pertaining to distribution of the software without
13	* specific, written prior permission. The Vrije Universiteit makes no	13	* specific, written prior permission. The Vrije Universiteit makes no
14	* representations about the suitability of this software for any purpose.	14	* representations about the suitability of this software for any purpose.
15	* It is provided "as is" without express or implied warranty.	15	* It is provided "as is" without express or implied warranty.
16	*	16	*
17	* The Vrije Universiteit DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS	17	* The Vrije Universiteit DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
18	* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,	18	* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
19	* IN NO EVENT SHALL The Vrije Universiteit BE LIABLE FOR ANY SPECIAL,	19	* IN NO EVENT SHALL The Vrije Universiteit BE LIABLE FOR ANY SPECIAL,
20	* INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM	20	* INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
21	* LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE	21	* LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
22	* OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR	22	* OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
23	* PERFORMANCE OF THIS SOFTWARE.	23	* PERFORMANCE OF THIS SOFTWARE.
24	*/	24	*/
25		25
26	/*	26	/*
27	* assyntax.h	27	* assyntax.h
28	*	28	*
29	* Select the syntax appropriate to the 386 assembler being used	29	* Select the syntax appropriate to the 386 assembler being used
30	* To add support for more assemblers add more columns to the CHOICE	30	* To add support for more assemblers add more columns to the CHOICE
31	* macro. Note that register names must also have uppercase names	31	* macro. Note that register names must also have uppercase names
32	* to avoid macro recursion. e.g., #define ah %ah recurses!	32	* to avoid macro recursion. e.g., #define ah %ah recurses!
33	*	33	*
34	* NB 1. Some of the macros for certain assemblers imply that the code is to	34	* NB 1. Some of the macros for certain assemblers imply that the code is to
35	* run in protected mode!! Caveat emptor.	35	* run in protected mode!! Caveat emptor.
36	*	36	*
37	* NB 2. 486 specific instructions are not included. This is to discourage	37	* NB 2. 486 specific instructions are not included. This is to discourage
38	* their accidental use in code that is intended to run on 386 and 486	38	* their accidental use in code that is intended to run on 386 and 486
39	* systems.	39	* systems.
40	*	40	*
41	* Supported assemblers:	41	* Supported assemblers:
42	*	42	*
43	* (a) AT&T SysVr4 as(1): define ATT_ASSEMBLER	43	* (a) AT&T SysVr4 as(1): define ATT_ASSEMBLER
44	* (b) GNU Assembler gas: define GNU_ASSEMBLER (default)	44	* (b) GNU Assembler gas: define GNU_ASSEMBLER (default)
45	* (c) Amsterdam Compiler kit: define ACK_ASSEMBLER	45	* (c) Amsterdam Compiler kit: define ACK_ASSEMBLER
46	* (d) The Netwide Assembler: define NASM_ASSEMBLER	46	* (d) The Netwide Assembler: define NASM_ASSEMBLER
47	* (e) Microsoft Assembler: define MASM_ASSEMBLER (UNTESTED!)	47	* (e) Microsoft Assembler: define MASM_ASSEMBLER (UNTESTED!)
48	*	48	*
49	* The following naming conventions have been used to identify the various	49	* The following naming conventions have been used to identify the various
50	* data types:	50	* data types:
51	* _SR = segment register version	51	* _SR = segment register version
52	* Integer:	52	* Integer:
53	* _Q = quadword = 64 bits	53	* _Q = quadword = 64 bits
54	* _L = long = 32 bits	54	* _L = long = 32 bits
55	* _W = short = 16 bits	55	* _W = short = 16 bits
56	* _B = byte = 8 bits	56	* _B = byte = 8 bits
57	* Floating-point:	57	* Floating-point:
58	* _X = m80real = 80 bits	58	* _X = m80real = 80 bits
59	* _D = double = 64 bits	59	* _D = double = 64 bits
60	* _S = single = 32 bits	60	* _S = single = 32 bits
61	*	61	*
62	* Author: Gregory J. Sharp, Sept 1992	62	* Author: Gregory J. Sharp, Sept 1992
63	* Vrije Universiteit, Amsterdam, The Netherlands	63	* Vrije Universiteit, Amsterdam, The Netherlands
64	*	64	*
65	* [support for Intel syntax added by Josh Vanderhoof, 1999]	65	* [support for Intel syntax added by Josh Vanderhoof, 1999]
66	*/	66	*/
67		67
68	#if !(defined(NASM_ASSEMBLER) \|\| defined(MASM_ASSEMBLER))	68	#if !(defined(NASM_ASSEMBLER) \|\| defined(MASM_ASSEMBLER))
69		69
70	/* Default to ATT_ASSEMBLER when SVR4 or SYSV are defined */	70	/* Default to ATT_ASSEMBLER when SVR4 or SYSV are defined */
71	#if (defined(SVR4) \|\| defined(SYSV)) && !defined(GNU_ASSEMBLER)	71	#if (defined(SVR4) \|\| defined(SYSV)) && !defined(GNU_ASSEMBLER)
72	#define ATT_ASSEMBLER	72	#define ATT_ASSEMBLER
73	#endif	73	#endif
74		74
75	#if !defined(ATT_ASSEMBLER) && !defined(GNU_ASSEMBLER) && !defined(ACK_ASSEMBLER)	75	#if !defined(ATT_ASSEMBLER) && !defined(GNU_ASSEMBLER) && !defined(ACK_ASSEMBLER)
76	#define GNU_ASSEMBLER	76	#define GNU_ASSEMBLER
77	#endif	77	#endif
78		78
79	#if (defined(__STDC__) && !defined(UNIXCPP)) \|\| (defined (sun) && defined (i386) && defined (SVR4) && defined (__STDC__) && !defined (__GNUC__))	79	#if (defined(__STDC__) && !defined(UNIXCPP)) \|\| (defined (sun) && defined (i386) && defined (SVR4) && defined (__STDC__) && !defined (__GNUC__))
80	#define CONCAT(x, y) x ## y	80	#define CONCAT(x, y) x ## y
81	#define CONCAT3(x, y, z) x ## y ## z	81	#define CONCAT3(x, y, z) x ## y ## z
82	#else	82	#else
83	#define CONCAT(x, y) x/**/y	83	#define CONCAT(x, y) x/**/y
84	#define CONCAT3(x, y, z) x//y//z	84	#define CONCAT3(x, y, z) x//y//z
85	#endif	85	#endif
86		86
87	#ifdef ACK_ASSEMBLER	87	#ifdef ACK_ASSEMBLER
88		88
89	/* Assume we write code for 32-bit protected mode! */	89	/* Assume we write code for 32-bit protected mode! */
90		90
91	/* Redefine register names for GAS & AT&T assemblers */	91	/* Redefine register names for GAS & AT&T assemblers */
92	#define AL al	92	#define AL al
93	#define AH ah	93	#define AH ah
94	#define AX ax	94	#define AX ax
95	#define EAX ax	95	#define EAX ax
96	#define BL bl	96	#define BL bl
97	#define BH bh	97	#define BH bh
98	#define BX bx	98	#define BX bx
99	#define EBX bx	99	#define EBX bx
100	#define CL cl	100	#define CL cl
101	#define CH ch	101	#define CH ch
102	#define CX cx	102	#define CX cx
103	#define ECX cx	103	#define ECX cx
104	#define DL dl	104	#define DL dl
105	#define DH dh	105	#define DH dh
106	#define DX dx	106	#define DX dx
107	#define EDX dx	107	#define EDX dx
108	#define BP bp	108	#define BP bp
109	#define EBP bp	109	#define EBP bp
110	#define SI si	110	#define SI si
111	#define ESI si	111	#define ESI si
112	#define DI di	112	#define DI di
113	#define EDI di	113	#define EDI di
114	#define SP sp	114	#define SP sp
115	#define ESP sp	115	#define ESP sp
116	#define CS cs	116	#define CS cs
117	#define SS ss	117	#define SS ss
118	#define DS ds	118	#define DS ds
119	#define ES es	119	#define ES es
120	#define FS fs	120	#define FS fs
121	#define GS gs	121	#define GS gs
122	/* Control Registers */	122	/* Control Registers */
123	#define CR0 cr0	123	#define CR0 cr0
124	#define CR1 cr1	124	#define CR1 cr1
125	#define CR2 cr2	125	#define CR2 cr2
126	#define CR3 cr3	126	#define CR3 cr3
127	/* Debug Registers */	127	/* Debug Registers */
128	#define DR0 dr0	128	#define DR0 dr0
129	#define DR1 dr1	129	#define DR1 dr1
130	#define DR2 dr2	130	#define DR2 dr2
131	#define DR3 dr3	131	#define DR3 dr3
132	#define DR4 dr4	132	#define DR4 dr4
133	#define DR5 dr5	133	#define DR5 dr5
134	#define DR6 dr6	134	#define DR6 dr6
135	#define DR7 dr7	135	#define DR7 dr7
136	/* Floating-point Stack */	136	/* Floating-point Stack */
137	#define ST st	137	#define ST st
138		138
139	#define AS_BEGIN .sect .text; .sect .rom; .sect .data; .sect .bss; .sect .text	139	#define AS_BEGIN .sect .text; .sect .rom; .sect .data; .sect .bss; .sect .text
140		140
141		141
142	#define _WTOG o16 /* word toggle for _W instructions */	142	#define _WTOG o16 /* word toggle for _W instructions */
143	#define _LTOG /* long toggle for _L instructions */	143	#define _LTOG /* long toggle for _L instructions */
144	#define ADDR_TOGGLE a16	144	#define ADDR_TOGGLE a16
145	#define OPSZ_TOGGLE o16	145	#define OPSZ_TOGGLE o16
146	#define USE16 .use16	146	#define USE16 .use16
147	#define USE32 .use32	147	#define USE32 .use32
148		148
149	#define CHOICE(a,b,c) c	149	#define CHOICE(a,b,c) c
150		150
151	#else /* AT&T or GAS */	151	#else /* AT&T or GAS */
152		152
153	/* Redefine register names for GAS & AT&T assemblers */	153	/* Redefine register names for GAS & AT&T assemblers */
154	#define AL %al	154	#define AL %al
155	#define AH %ah	155	#define AH %ah
156	#define AX %ax	156	#define AX %ax
157	#define EAX %eax	157	#define EAX %eax
158	#define BL %bl	158	#define BL %bl
159	#define BH %bh	159	#define BH %bh
160	#define BX %bx	160	#define BX %bx
161	#define EBX %ebx	161	#define EBX %ebx
162	#define CL %cl	162	#define CL %cl
163	#define CH %ch	163	#define CH %ch
164	#define CX %cx	164	#define CX %cx
165	#define ECX %ecx	165	#define ECX %ecx
166	#define DL %dl	166	#define DL %dl
167	#define DH %dh	167	#define DH %dh
168	#define DX %dx	168	#define DX %dx
169	#define EDX %edx	169	#define EDX %edx
170	#define BP %bp	170	#define BP %bp
171	#define EBP %ebp	171	#define EBP %ebp
172	#define SI %si	172	#define SI %si
173	#define ESI %esi	173	#define ESI %esi
174	#define DI %di	174	#define DI %di
175	#define EDI %edi	175	#define EDI %edi
176	#define SP %sp	176	#define SP %sp
177	#define ESP %esp	177	#define ESP %esp
178	#define CS %cs	178	#define CS %cs
179	#define SS %ss	179	#define SS %ss
180	#define DS %ds	180	#define DS %ds
181	#define ES %es	181	#define ES %es
182	#define FS %fs	182	#define FS %fs
183	#define GS %gs	183	#define GS %gs
184	/* Control Registers */	184	/* Control Registers */
185	#define CR0 %cr0	185	#define CR0 %cr0
186	#define CR1 %cr1	186	#define CR1 %cr1
187	#define CR2 %cr2	187	#define CR2 %cr2
188	#define CR3 %cr3	188	#define CR3 %cr3
189	/* Debug Registers */	189	/* Debug Registers */
190	#define DR0 %db0	190	#define DR0 %db0
191	#define DR1 %db1	191	#define DR1 %db1
192	#define DR2 %db2	192	#define DR2 %db2
193	#define DR3 %db3	193	#define DR3 %db3
194	#define DR4 %db4	194	#define DR4 %db4
195	#define DR5 %db5	195	#define DR5 %db5
196	#define DR6 %db6	196	#define DR6 %db6
197	#define DR7 %db7	197	#define DR7 %db7
198	/* Floating-point Stack */	198	/* Floating-point Stack */
199	#define _STX0 %st(0)	199	#define _STX0 %st(0)
200	#define _STX1 %st(1)	200	#define _STX1 %st(1)
201	#define _STX2 %st(2)	201	#define _STX2 %st(2)
202	#define _STX3 %st(3)	202	#define _STX3 %st(3)
203	#define _STX4 %st(4)	203	#define _STX4 %st(4)
204	#define _STX5 %st(5)	204	#define _STX5 %st(5)
205	#define _STX6 %st(6)	205	#define _STX6 %st(6)
206	#define _STX7 %st(7)	206	#define _STX7 %st(7)
207	#define ST(x) CONCAT(_STX,x)	207	#define ST(x) CONCAT(_STX,x)
208	#ifdef GNU_ASSEMBLER	208	#ifdef GNU_ASSEMBLER
209	#define ST0 %st(0)	209	#define ST0 %st(0)
210	#else	210	#else
211	#define ST0 %st	211	#define ST0 %st
212	#endif	212	#endif
213	/* MMX Registers */	213	/* MMX Registers */
214	#define MM0 %mm0	214	#define MM0 %mm0
215	#define MM1 %mm1	215	#define MM1 %mm1
216	#define MM2 %mm2	216	#define MM2 %mm2
217	#define MM3 %mm3	217	#define MM3 %mm3
218	#define MM4 %mm4	218	#define MM4 %mm4
219	#define MM5 %mm5	219	#define MM5 %mm5
220	#define MM6 %mm6	220	#define MM6 %mm6
221	#define MM7 %mm7	221	#define MM7 %mm7
222	/* SSE Registers */	222	/* SSE Registers */
223	#define XMM0 %xmm0	223	#define XMM0 %xmm0
224	#define XMM1 %xmm1	224	#define XMM1 %xmm1
225	#define XMM2 %xmm2	225	#define XMM2 %xmm2
226	#define XMM3 %xmm3	226	#define XMM3 %xmm3
227	#define XMM4 %xmm4	227	#define XMM4 %xmm4
228	#define XMM5 %xmm5	228	#define XMM5 %xmm5
229	#define XMM6 %xmm6	229	#define XMM6 %xmm6
230	#define XMM7 %xmm7	230	#define XMM7 %xmm7
231		231
232	#define AS_BEGIN	232	#define AS_BEGIN
233	#define USE16	233	#define USE16
234	#define USE32	234	#define USE32
235		235
236	#ifdef GNU_ASSEMBLER	236	#ifdef GNU_ASSEMBLER
237		237
238	#define ADDR_TOGGLE aword	238	#define ADDR_TOGGLE aword
239	#define OPSZ_TOGGLE word	239	#define OPSZ_TOGGLE word
240		240
241	#define CHOICE(a,b,c) b	241	#define CHOICE(a,b,c) b
242		242
243	#else	243	#else
244	/*	244	/*
245	* AT&T ASSEMBLER SYNTAX	245	* AT&T ASSEMBLER SYNTAX
246	* *********************	246	* *********************
247	*/	247	*/
248	#define CHOICE(a,b,c) a	248	#define CHOICE(a,b,c) a
249		249
250	#define ADDR_TOGGLE addr16	250	#define ADDR_TOGGLE addr16
251	#define OPSZ_TOGGLE data16	251	#define OPSZ_TOGGLE data16
252		252
253	#endif /* GNU_ASSEMBLER */	253	#endif /* GNU_ASSEMBLER */
254	#endif /* ACK_ASSEMBLER */	254	#endif /* ACK_ASSEMBLER */
255		255
256		-
257	#if defined(__QNX__) \|\| defined(Lynx) \|\| (defined(SYSV) \|\| defined(SVR4)) && !defined(ACK_ASSEMBLER) \|\| defined(__ELF__) \|\| defined(__GNU__) \|\| defined(__GNUC__) && !defined(__DJGPP__) && !defined(__MINGW32__)	-
258	#define GLNAME(a) a	-
259	#else	-
260	#define GLNAME(a) CONCAT(_,a)	256	#define GLNAME(a) CONCAT(_,a)
261	#endif	-
262		-
263		257
264	/****************************************/	258	/****************************************/
265	/* */	259	/* */
266	/* Select the various choices */	260	/* Select the various choices */
267	/* */	261	/* */
268	/****************************************/	262	/****************************************/
269		263
270		264
271	/* Redefine assembler directives */	265	/* Redefine assembler directives */
272	/*********************************/	266	/*********************************/
273	#define GLOBL CHOICE(.globl, .globl, .extern)	267	#define GLOBL CHOICE(.globl, .globl, .extern)
274	#define GLOBAL GLOBL	268	#define GLOBAL GLOBL
275	#define EXTERN GLOBL	269	#define EXTERN GLOBL
276	#ifndef __AOUT__	270	#ifndef __AOUT__
277	#define ALIGNTEXT32 CHOICE(.align 32, .balign 32, .align 32)	271	#define ALIGNTEXT32 CHOICE(.align 32, .balign 32, .align 32)
278	#define ALIGNTEXT16 CHOICE(.align 16, .balign 16, .align 16)	272	#define ALIGNTEXT16 CHOICE(.align 16, .balign 16, .align 16)
279	#define ALIGNTEXT8 CHOICE(.align 8, .balign 8, .align 8)	273	#define ALIGNTEXT8 CHOICE(.align 8, .balign 8, .align 8)
280	#define ALIGNTEXT4 CHOICE(.align 4, .balign 4, .align 4)	274	#define ALIGNTEXT4 CHOICE(.align 4, .balign 4, .align 4)
281	#define ALIGNTEXT2 CHOICE(.align 2, .balign 2, .align 2)	275	#define ALIGNTEXT2 CHOICE(.align 2, .balign 2, .align 2)
282	/* ALIGNTEXT4ifNOP is the same as ALIGNTEXT4, but only if the space is	276	/* ALIGNTEXT4ifNOP is the same as ALIGNTEXT4, but only if the space is
283	* guaranteed to be filled with NOPs. Otherwise it does nothing.	277	* guaranteed to be filled with NOPs. Otherwise it does nothing.
284	*/	278	*/
285	#define ALIGNTEXT32ifNOP CHOICE(.align 32, .balign ARG2(32,0x90), /can't do it/)	279	#define ALIGNTEXT32ifNOP CHOICE(.align 32, .balign ARG2(32,0x90), /can't do it/)
286	#define ALIGNTEXT16ifNOP CHOICE(.align 16, .balign ARG2(16,0x90), /can't do it/)	280	#define ALIGNTEXT16ifNOP CHOICE(.align 16, .balign ARG2(16,0x90), /can't do it/)
287	#define ALIGNTEXT8ifNOP CHOICE(.align 8, .balign ARG2(8,0x90), /can't do it/)	281	#define ALIGNTEXT8ifNOP CHOICE(.align 8, .balign ARG2(8,0x90), /can't do it/)
288	#define ALIGNTEXT4ifNOP CHOICE(.align 4, .balign ARG2(4,0x90), /can't do it/)	282	#define ALIGNTEXT4ifNOP CHOICE(.align 4, .balign ARG2(4,0x90), /can't do it/)
289	#define ALIGNDATA32 CHOICE(.align 32, .balign ARG2(32,0x0), .align 32)	283	#define ALIGNDATA32 CHOICE(.align 32, .balign ARG2(32,0x0), .align 32)
290	#define ALIGNDATA16 CHOICE(.align 16, .balign ARG2(16,0x0), .align 16)	284	#define ALIGNDATA16 CHOICE(.align 16, .balign ARG2(16,0x0), .align 16)
291	#define ALIGNDATA8 CHOICE(.align 8, .balign ARG2(8,0x0), .align 8)	285	#define ALIGNDATA8 CHOICE(.align 8, .balign ARG2(8,0x0), .align 8)
292	#define ALIGNDATA4 CHOICE(.align 4, .balign ARG2(4,0x0), .align 4)	286	#define ALIGNDATA4 CHOICE(.align 4, .balign ARG2(4,0x0), .align 4)
293	#define ALIGNDATA2 CHOICE(.align 2, .balign ARG2(2,0x0), .align 2)	287	#define ALIGNDATA2 CHOICE(.align 2, .balign ARG2(2,0x0), .align 2)
294	#else	288	#else
295	/* 'as -aout' on FreeBSD doesn't have .balign */	289	/* 'as -aout' on FreeBSD doesn't have .balign */
296	#define ALIGNTEXT32 CHOICE(.align 32, .align ARG2(5,0x90), .align 32)	290	#define ALIGNTEXT32 CHOICE(.align 32, .align ARG2(5,0x90), .align 32)
297	#define ALIGNTEXT16 CHOICE(.align 16, .align ARG2(4,0x90), .align 16)	291	#define ALIGNTEXT16 CHOICE(.align 16, .align ARG2(4,0x90), .align 16)
298	#define ALIGNTEXT8 CHOICE(.align 8, .align ARG2(3,0x90), .align 8)	292	#define ALIGNTEXT8 CHOICE(.align 8, .align ARG2(3,0x90), .align 8)
299	#define ALIGNTEXT4 CHOICE(.align 4, .align ARG2(2,0x90), .align 4)	293	#define ALIGNTEXT4 CHOICE(.align 4, .align ARG2(2,0x90), .align 4)
300	#define ALIGNTEXT2 CHOICE(.align 2, .align ARG2(1,0x90), .align 2)	294	#define ALIGNTEXT2 CHOICE(.align 2, .align ARG2(1,0x90), .align 2)
301	/* ALIGNTEXT4ifNOP is the same as ALIGNTEXT4, but only if the space is	295	/* ALIGNTEXT4ifNOP is the same as ALIGNTEXT4, but only if the space is
302	* guaranteed to be filled with NOPs. Otherwise it does nothing.	296	* guaranteed to be filled with NOPs. Otherwise it does nothing.
303	*/	297	*/
304	#define ALIGNTEXT32ifNOP CHOICE(.align 32, .align ARG2(5,0x90), /can't do it/)	298	#define ALIGNTEXT32ifNOP CHOICE(.align 32, .align ARG2(5,0x90), /can't do it/)
305	#define ALIGNTEXT16ifNOP CHOICE(.align 16, .align ARG2(4,0x90), /can't do it/)	299	#define ALIGNTEXT16ifNOP CHOICE(.align 16, .align ARG2(4,0x90), /can't do it/)
306	#define ALIGNTEXT8ifNOP CHOICE(.align 8, .align ARG2(3,0x90), /can't do it/)	300	#define ALIGNTEXT8ifNOP CHOICE(.align 8, .align ARG2(3,0x90), /can't do it/)
307	#define ALIGNTEXT4ifNOP CHOICE(.align 4, .align ARG2(2,0x90), /can't do it/)	301	#define ALIGNTEXT4ifNOP CHOICE(.align 4, .align ARG2(2,0x90), /can't do it/)
308	#define ALIGNDATA32 CHOICE(.align 32, .align ARG2(5,0x0), .align 32)	302	#define ALIGNDATA32 CHOICE(.align 32, .align ARG2(5,0x0), .align 32)
309	#define ALIGNDATA16 CHOICE(.align 16, .align ARG2(4,0x0), .align 16)	303	#define ALIGNDATA16 CHOICE(.align 16, .align ARG2(4,0x0), .align 16)
310	#define ALIGNDATA8 CHOICE(.align 8, .align ARG2(3,0x0), .align 8)	304	#define ALIGNDATA8 CHOICE(.align 8, .align ARG2(3,0x0), .align 8)
311	#define ALIGNDATA4 CHOICE(.align 4, .align ARG2(2,0x0), .align 4)	305	#define ALIGNDATA4 CHOICE(.align 4, .align ARG2(2,0x0), .align 4)
312	#define ALIGNDATA2 CHOICE(.align 2, .align ARG2(1,0x0), .align 2)	306	#define ALIGNDATA2 CHOICE(.align 2, .align ARG2(1,0x0), .align 2)
313	#endif /* __AOUT__ */	307	#endif /* __AOUT__ */
314	#define FILE(s) CHOICE(.file s, .file s, .file s)	308	#define FILE(s) CHOICE(.file s, .file s, .file s)
315	#define STRING(s) CHOICE(.string s, .asciz s, .asciz s)	309	#define STRING(s) CHOICE(.string s, .asciz s, .asciz s)
316	#define D_LONG CHOICE(.long, .long, .data4)	310	#define D_LONG CHOICE(.long, .long, .data4)
317	#define D_WORD CHOICE(.value, .short, .data2)	311	#define D_WORD CHOICE(.value, .short, .data2)
318	#define D_BYTE CHOICE(.byte, .byte, .data1)	312	#define D_BYTE CHOICE(.byte, .byte, .data1)
319	#define SPACE CHOICE(.comm, .space, .space)	313	#define SPACE CHOICE(.comm, .space, .space)
320	#define COMM CHOICE(.comm, .comm, .comm)	314	#define COMM CHOICE(.comm, .comm, .comm)
321	#define SEG_DATA CHOICE(.data, .data, .sect .data)	315	#define SEG_DATA CHOICE(.data, .data, .sect .data)
322	#define SEG_TEXT CHOICE(.text, .text, .sect .text)	316	#define SEG_TEXT CHOICE(.text, .text, .sect .text)
323	#define SEG_BSS CHOICE(.bss, .bss, .sect .bss)	317	#define SEG_BSS CHOICE(.bss, .bss, .sect .bss)
324		318
325	#ifdef GNU_ASSEMBLER	319	#ifdef GNU_ASSEMBLER
326	#define D_SPACE(n) . = . + n	320	#define D_SPACE(n) . = . + n
327	#else	321	#else
328	#define D_SPACE(n) .space n	322	#define D_SPACE(n) .space n
329	#endif	323	#endif
330		324
331	/* Addressing Modes */	325	/* Addressing Modes */
332	/* Immediate Mode */	326	/* Immediate Mode */
333	#define ADDR(a) CHOICE(CONCAT($,a), $a, a)	327	#define ADDR(a) CHOICE(CONCAT($,a), $a, a)
334	#define CONST(a) CHOICE(CONCAT($,a), $a, a)	328	#define CONST(a) CHOICE(CONCAT($,a), $a, a)
335		329
336	/* Indirect Mode */	330	/* Indirect Mode */
337	#define CONTENT(a) CHOICE(a, a, (a)) /* take contents of variable */	331	#define CONTENT(a) CHOICE(a, a, (a)) /* take contents of variable */
338	#define REGIND(a) CHOICE((a), (a), (a)) /* Register a indirect */	332	#define REGIND(a) CHOICE((a), (a), (a)) /* Register a indirect */
339	/* Register b indirect plus displacement a */	333	/* Register b indirect plus displacement a */
340	#define REGOFF(a, b) CHOICE(a(b), a(b), a(b))	334	#define REGOFF(a, b) CHOICE(a(b), a(b), a(b))
341	/* Reg indirect Base + Index + Displacement - this is mainly for 16-bit mode	335	/* Reg indirect Base + Index + Displacement - this is mainly for 16-bit mode
342	* which has no scaling	336	* which has no scaling
343	*/	337	*/
344	#define REGBID(b,i,d) CHOICE(d(b,i), d(b,i), d(b)(i))	338	#define REGBID(b,i,d) CHOICE(d(b,i), d(b,i), d(b)(i))
345	/* Reg indirect Base + (Index * Scale) */	339	/* Reg indirect Base + (Index * Scale) */
346	#define REGBIS(b,i,s) CHOICE((b,i,s), (b,i,s), (b)(i*s))	340	#define REGBIS(b,i,s) CHOICE((b,i,s), (b,i,s), (b)(i*s))
347	/* Reg indirect Base + (Index * Scale) + Displacement */	341	/* Reg indirect Base + (Index * Scale) + Displacement */
348	#define REGBISD(b,i,s,d) CHOICE(d(b,i,s), d(b,i,s), d(b)(i*s))	342	#define REGBISD(b,i,s,d) CHOICE(d(b,i,s), d(b,i,s), d(b)(i*s))
349	/* Displaced Scaled Index: */	343	/* Displaced Scaled Index: */
350	#define REGDIS(d,i,s) CHOICE(d(,i,s), d(,i,s), d(i * s))	344	#define REGDIS(d,i,s) CHOICE(d(,i,s), d(,i,s), d(i * s))
351	/* Indexed Base: */	345	/* Indexed Base: */
352	#define REGBI(b,i) CHOICE((b,i), (b,i), (b)(i))	346	#define REGBI(b,i) CHOICE((b,i), (b,i), (b)(i))
353	/* Displaced Base: */	347	/* Displaced Base: */
354	#define REGDB(d,b) CHOICE(d(b), d(b), d(b))	348	#define REGDB(d,b) CHOICE(d(b), d(b), d(b))
355	/* Variable indirect: */	349	/* Variable indirect: */
356	#define VARINDIRECT(var) CHOICE(var, var, (var))	350	#define VARINDIRECT(var) CHOICE(var, var, (var))
357	/* Use register contents as jump/call target: */	351	/* Use register contents as jump/call target: */
358	#define CODEPTR(reg) CHOICE(reg, reg, reg)	352	#define CODEPTR(reg) CHOICE(reg, reg, reg)
359		353
360	/* For expressions requiring bracketing	354	/* For expressions requiring bracketing
361	* eg. (CRT0_PM \| CRT_EM)	355	* eg. (CRT0_PM \| CRT_EM)
362	*/	356	*/
363		357
364	#define EXPR(a) CHOICE([a], (a), [a])	358	#define EXPR(a) CHOICE([a], (a), [a])
365	#define ENOT(a) CHOICE(0!a, ~a, ~a)	359	#define ENOT(a) CHOICE(0!a, ~a, ~a)
366	#define EMUL(a,b) CHOICE(a\b, ab, a*b)	360	#define EMUL(a,b) CHOICE(a\b, ab, a*b)
367	#define EDIV(a,b) CHOICE(a\/b, a/b, a/b)	361	#define EDIV(a,b) CHOICE(a\/b, a/b, a/b)
368		362
369	/*	363	/*
370	* We have to beat the problem of commas within arguments to choice.	364	* We have to beat the problem of commas within arguments to choice.
371	* eg. choice (add a,b, add b,a) will get argument mismatch. Luckily ANSI	365	* eg. choice (add a,b, add b,a) will get argument mismatch. Luckily ANSI
372	* and other known cpp definitions evaluate arguments before substitution	366	* and other known cpp definitions evaluate arguments before substitution
373	* so the following works.	367	* so the following works.
374	*/	368	*/
375	#define ARG2(a, b) a,b	369	#define ARG2(a, b) a,b
376	#define ARG3(a,b,c) a,b,c	370	#define ARG3(a,b,c) a,b,c
377		371
378	/* Redefine assembler commands */	372	/* Redefine assembler commands */
379	#define AAA CHOICE(aaa, aaa, aaa)	373	#define AAA CHOICE(aaa, aaa, aaa)
380	#define AAD CHOICE(aad, aad, aad)	374	#define AAD CHOICE(aad, aad, aad)
381	#define AAM CHOICE(aam, aam, aam)	375	#define AAM CHOICE(aam, aam, aam)
382	#define AAS CHOICE(aas, aas, aas)	376	#define AAS CHOICE(aas, aas, aas)
383	#define ADC_L(a, b) CHOICE(adcl ARG2(a,b), adcl ARG2(a,b), _LTOG adc ARG2(b,a))	377	#define ADC_L(a, b) CHOICE(adcl ARG2(a,b), adcl ARG2(a,b), _LTOG adc ARG2(b,a))
384	#define ADC_W(a, b) CHOICE(adcw ARG2(a,b), adcw ARG2(a,b), _WTOG adc ARG2(b,a))	378	#define ADC_W(a, b) CHOICE(adcw ARG2(a,b), adcw ARG2(a,b), _WTOG adc ARG2(b,a))
385	#define ADC_B(a, b) CHOICE(adcb ARG2(a,b), adcb ARG2(a,b), adcb ARG2(b,a))	379	#define ADC_B(a, b) CHOICE(adcb ARG2(a,b), adcb ARG2(a,b), adcb ARG2(b,a))
386	#define ADD_L(a, b) CHOICE(addl ARG2(a,b), addl ARG2(a,b), _LTOG add ARG2(b,a))	380	#define ADD_L(a, b) CHOICE(addl ARG2(a,b), addl ARG2(a,b), _LTOG add ARG2(b,a))
387	#define ADD_W(a, b) CHOICE(addw ARG2(a,b), addw ARG2(a,b), _WTOG add ARG2(b,a))	381	#define ADD_W(a, b) CHOICE(addw ARG2(a,b), addw ARG2(a,b), _WTOG add ARG2(b,a))
388	#define ADD_B(a, b) CHOICE(addb ARG2(a,b), addb ARG2(a,b), addb ARG2(b,a))	382	#define ADD_B(a, b) CHOICE(addb ARG2(a,b), addb ARG2(a,b), addb ARG2(b,a))
389	#define AND_L(a, b) CHOICE(andl ARG2(a,b), andl ARG2(a,b), _LTOG and ARG2(b,a))	383	#define AND_L(a, b) CHOICE(andl ARG2(a,b), andl ARG2(a,b), _LTOG and ARG2(b,a))
390	#define AND_W(a, b) CHOICE(andw ARG2(a,b), andw ARG2(a,b), _WTOG and ARG2(b,a))	384	#define AND_W(a, b) CHOICE(andw ARG2(a,b), andw ARG2(a,b), _WTOG and ARG2(b,a))
391	#define AND_B(a, b) CHOICE(andb ARG2(a,b), andb ARG2(a,b), andb ARG2(b,a))	385	#define AND_B(a, b) CHOICE(andb ARG2(a,b), andb ARG2(a,b), andb ARG2(b,a))
392	#define ARPL(a,b) CHOICE(arpl ARG2(a,b), arpl ARG2(a,b), arpl ARG2(b,a))	386	#define ARPL(a,b) CHOICE(arpl ARG2(a,b), arpl ARG2(a,b), arpl ARG2(b,a))
393	#define BOUND_L(a, b) CHOICE(boundl ARG2(a,b), boundl ARG2(b,a), _LTOG bound ARG2(b,a))	387	#define BOUND_L(a, b) CHOICE(boundl ARG2(a,b), boundl ARG2(b,a), _LTOG bound ARG2(b,a))
394	#define BOUND_W(a, b) CHOICE(boundw ARG2(a,b), boundw ARG2(b,a), _WTOG bound ARG2(b,a))	388	#define BOUND_W(a, b) CHOICE(boundw ARG2(a,b), boundw ARG2(b,a), _WTOG bound ARG2(b,a))
395	#define BSF_L(a, b) CHOICE(bsfl ARG2(a,b), bsfl ARG2(a,b), _LTOG bsf ARG2(b,a))	389	#define BSF_L(a, b) CHOICE(bsfl ARG2(a,b), bsfl ARG2(a,b), _LTOG bsf ARG2(b,a))
396	#define BSF_W(a, b) CHOICE(bsfw ARG2(a,b), bsfw ARG2(a,b), _WTOG bsf ARG2(b,a))	390	#define BSF_W(a, b) CHOICE(bsfw ARG2(a,b), bsfw ARG2(a,b), _WTOG bsf ARG2(b,a))
397	#define BSR_L(a, b) CHOICE(bsrl ARG2(a,b), bsrl ARG2(a,b), _LTOG bsr ARG2(b,a))	391	#define BSR_L(a, b) CHOICE(bsrl ARG2(a,b), bsrl ARG2(a,b), _LTOG bsr ARG2(b,a))
398	#define BSR_W(a, b) CHOICE(bsrw ARG2(a,b), bsrw ARG2(a,b), _WTOG bsr ARG2(b,a))	392	#define BSR_W(a, b) CHOICE(bsrw ARG2(a,b), bsrw ARG2(a,b), _WTOG bsr ARG2(b,a))
399	#define BT_L(a, b) CHOICE(btl ARG2(a,b), btl ARG2(a,b), _LTOG bt ARG2(b,a))	393	#define BT_L(a, b) CHOICE(btl ARG2(a,b), btl ARG2(a,b), _LTOG bt ARG2(b,a))
400	#define BT_W(a, b) CHOICE(btw ARG2(a,b), btw ARG2(a,b), _WTOG bt ARG2(b,a))	394	#define BT_W(a, b) CHOICE(btw ARG2(a,b), btw ARG2(a,b), _WTOG bt ARG2(b,a))
401	#define BTC_L(a, b) CHOICE(btcl ARG2(a,b), btcl ARG2(a,b), _LTOG btc ARG2(b,a))	395	#define BTC_L(a, b) CHOICE(btcl ARG2(a,b), btcl ARG2(a,b), _LTOG btc ARG2(b,a))
402	#define BTC_W(a, b) CHOICE(btcw ARG2(a,b), btcw ARG2(a,b), _WTOG btc ARG2(b,a))	396	#define BTC_W(a, b) CHOICE(btcw ARG2(a,b), btcw ARG2(a,b), _WTOG btc ARG2(b,a))
403	#define BTR_L(a, b) CHOICE(btrl ARG2(a,b), btrl ARG2(a,b), _LTOG btr ARG2(b,a))	397	#define BTR_L(a, b) CHOICE(btrl ARG2(a,b), btrl ARG2(a,b), _LTOG btr ARG2(b,a))
404	#define BTR_W(a, b) CHOICE(btrw ARG2(a,b), btrw ARG2(a,b), _WTOG btr ARG2(b,a))	398	#define BTR_W(a, b) CHOICE(btrw ARG2(a,b), btrw ARG2(a,b), _WTOG btr ARG2(b,a))
405	#define BTS_L(a, b) CHOICE(btsl ARG2(a,b), btsl ARG2(a,b), _LTOG bts ARG2(b,a))	399	#define BTS_L(a, b) CHOICE(btsl ARG2(a,b), btsl ARG2(a,b), _LTOG bts ARG2(b,a))
406	#define BTS_W(a, b) CHOICE(btsw ARG2(a,b), btsw ARG2(a,b), _WTOG bts ARG2(b,a))	400	#define BTS_W(a, b) CHOICE(btsw ARG2(a,b), btsw ARG2(a,b), _WTOG bts ARG2(b,a))
407	#define CALL(a) CHOICE(call a, call a, call a)	401	#define CALL(a) CHOICE(call a, call a, call a)
408	#define CALLF(s,a) CHOICE(lcall ARG2(s,a), lcall ARG2(s,a), callf s:a)	402	#define CALLF(s,a) CHOICE(lcall ARG2(s,a), lcall ARG2(s,a), callf s:a)
409	#define CBW CHOICE(cbtw, cbw, cbw)	403	#define CBW CHOICE(cbtw, cbw, cbw)
410	#define CWDE CHOICE(cwtd, cwde, cwde)	404	#define CWDE CHOICE(cwtd, cwde, cwde)
411	#define CLC CHOICE(clc, clc, clc)	405	#define CLC CHOICE(clc, clc, clc)
412	#define CLD CHOICE(cld, cld, cld)	406	#define CLD CHOICE(cld, cld, cld)
413	#define CLI CHOICE(cli, cli, cli)	407	#define CLI CHOICE(cli, cli, cli)
414	#define CLTS CHOICE(clts, clts, clts)	408	#define CLTS CHOICE(clts, clts, clts)
415	#define CMC CHOICE(cmc, cmc, cmc)	409	#define CMC CHOICE(cmc, cmc, cmc)
416	#define CMP_L(a, b) CHOICE(cmpl ARG2(a,b), cmpl ARG2(a,b), _LTOG cmp ARG2(b,a))	410	#define CMP_L(a, b) CHOICE(cmpl ARG2(a,b), cmpl ARG2(a,b), _LTOG cmp ARG2(b,a))
417	#define CMP_W(a, b) CHOICE(cmpw ARG2(a,b), cmpw ARG2(a,b), _WTOG cmp ARG2(b,a))	411	#define CMP_W(a, b) CHOICE(cmpw ARG2(a,b), cmpw ARG2(a,b), _WTOG cmp ARG2(b,a))
418	#define CMP_B(a, b) CHOICE(cmpb ARG2(a,b), cmpb ARG2(a,b), cmpb ARG2(b,a))	412	#define CMP_B(a, b) CHOICE(cmpb ARG2(a,b), cmpb ARG2(a,b), cmpb ARG2(b,a))
419	#define CMPS_L CHOICE(cmpsl, cmpsl, _LTOG cmps)	413	#define CMPS_L CHOICE(cmpsl, cmpsl, _LTOG cmps)
420	#define CMPS_W CHOICE(cmpsw, cmpsw, _WTOG cmps)	414	#define CMPS_W CHOICE(cmpsw, cmpsw, _WTOG cmps)
421	#define CMPS_B CHOICE(cmpsb, cmpsb, cmpsb)	415	#define CMPS_B CHOICE(cmpsb, cmpsb, cmpsb)
422	#define CWD CHOICE(cwtl, cwd, cwd)	416	#define CWD CHOICE(cwtl, cwd, cwd)
423	#define CDQ CHOICE(cltd, cdq, cdq)	417	#define CDQ CHOICE(cltd, cdq, cdq)
424	#define DAA CHOICE(daa, daa, daa)	418	#define DAA CHOICE(daa, daa, daa)
425	#define DAS CHOICE(das, das, das)	419	#define DAS CHOICE(das, das, das)
426	#define DEC_L(a) CHOICE(decl a, decl a, _LTOG dec a)	420	#define DEC_L(a) CHOICE(decl a, decl a, _LTOG dec a)
427	#define DEC_W(a) CHOICE(decw a, decw a, _WTOG dec a)	421	#define DEC_W(a) CHOICE(decw a, decw a, _WTOG dec a)
428	#define DEC_B(a) CHOICE(decb a, decb a, decb a)	422	#define DEC_B(a) CHOICE(decb a, decb a, decb a)
429	#define DIV_L(a) CHOICE(divl a, divl a, div a)	423	#define DIV_L(a) CHOICE(divl a, divl a, div a)
430	#define DIV_W(a) CHOICE(divw a, divw a, div a)	424	#define DIV_W(a) CHOICE(divw a, divw a, div a)
431	#define DIV_B(a) CHOICE(divb a, divb a, divb a)	425	#define DIV_B(a) CHOICE(divb a, divb a, divb a)
432	#define ENTER(a,b) CHOICE(enter ARG2(a,b), enter ARG2(a,b), enter ARG2(b,a))	426	#define ENTER(a,b) CHOICE(enter ARG2(a,b), enter ARG2(a,b), enter ARG2(b,a))
433	#define HLT CHOICE(hlt, hlt, hlt)	427	#define HLT CHOICE(hlt, hlt, hlt)
434	#define IDIV_L(a) CHOICE(idivl a, idivl a, _LTOG idiv a)	428	#define IDIV_L(a) CHOICE(idivl a, idivl a, _LTOG idiv a)
435	#define IDIV_W(a) CHOICE(idivw a, idivw a, _WTOG idiv a)	429	#define IDIV_W(a) CHOICE(idivw a, idivw a, _WTOG idiv a)
436	#define IDIV_B(a) CHOICE(idivb a, idivb a, idivb a)	430	#define IDIV_B(a) CHOICE(idivb a, idivb a, idivb a)
437	/* More forms than this for imul!! */	431	/* More forms than this for imul!! */
438	#define IMUL_L(a, b) CHOICE(imull ARG2(a,b), imull ARG2(a,b), _LTOG imul ARG2(b,a))	432	#define IMUL_L(a, b) CHOICE(imull ARG2(a,b), imull ARG2(a,b), _LTOG imul ARG2(b,a))
439	#define IMUL_W(a, b) CHOICE(imulw ARG2(a,b), imulw ARG2(a,b), _WTOG imul ARG2(b,a))	433	#define IMUL_W(a, b) CHOICE(imulw ARG2(a,b), imulw ARG2(a,b), _WTOG imul ARG2(b,a))
440	#define IMUL_B(a) CHOICE(imulb a, imulb a, imulb a)	434	#define IMUL_B(a) CHOICE(imulb a, imulb a, imulb a)
441	#define IN_L CHOICE(inl (DX), inl ARG2(DX,EAX), _LTOG in DX)	435	#define IN_L CHOICE(inl (DX), inl ARG2(DX,EAX), _LTOG in DX)
442	#define IN_W CHOICE(inw (DX), inw ARG2(DX,AX), _WTOG in DX)	436	#define IN_W CHOICE(inw (DX), inw ARG2(DX,AX), _WTOG in DX)
443	#define IN_B CHOICE(inb (DX), inb ARG2(DX,AL), inb DX)	437	#define IN_B CHOICE(inb (DX), inb ARG2(DX,AL), inb DX)
444	/* Please AS code writer: use the following ONLY, if you refer to ports<256	438	/* Please AS code writer: use the following ONLY, if you refer to ports<256
445	* directly, but not in IN1_W(DX), for instance, even if IN1_ looks nicer	439	* directly, but not in IN1_W(DX), for instance, even if IN1_ looks nicer
446	*/	440	*/
447	#if defined (sun)	441	#if defined (sun)
448	#define IN1_L(a) CHOICE(inl (a), inl ARG2(a,EAX), _LTOG in a)	442	#define IN1_L(a) CHOICE(inl (a), inl ARG2(a,EAX), _LTOG in a)
449	#define IN1_W(a) CHOICE(inw (a), inw ARG2(a,AX), _WTOG in a)	443	#define IN1_W(a) CHOICE(inw (a), inw ARG2(a,AX), _WTOG in a)
450	#define IN1_B(a) CHOICE(inb (a), inb ARG2(a,AL), inb a)	444	#define IN1_B(a) CHOICE(inb (a), inb ARG2(a,AL), inb a)
451	#else	445	#else
452	#define IN1_L(a) CHOICE(inl a, inl ARG2(a,EAX), _LTOG in a)	446	#define IN1_L(a) CHOICE(inl a, inl ARG2(a,EAX), _LTOG in a)
453	#define IN1_W(a) CHOICE(inw a, inw ARG2(a,AX), _WTOG in a)	447	#define IN1_W(a) CHOICE(inw a, inw ARG2(a,AX), _WTOG in a)
454	#define IN1_B(a) CHOICE(inb a, inb ARG2(a,AL), inb a)	448	#define IN1_B(a) CHOICE(inb a, inb ARG2(a,AL), inb a)
455	#endif	449	#endif
456	#define INC_L(a) CHOICE(incl a, incl a, _LTOG inc a)	450	#define INC_L(a) CHOICE(incl a, incl a, _LTOG inc a)
457	#define INC_W(a) CHOICE(incw a, incw a, _WTOG inc a)	451	#define INC_W(a) CHOICE(incw a, incw a, _WTOG inc a)
458	#define INC_B(a) CHOICE(incb a, incb a, incb a)	452	#define INC_B(a) CHOICE(incb a, incb a, incb a)
459	#define INS_L CHOICE(insl, insl, _LTOG ins)	453	#define INS_L CHOICE(insl, insl, _LTOG ins)
460	#define INS_W CHOICE(insw, insw, _WTOG ins)	454	#define INS_W CHOICE(insw, insw, _WTOG ins)
461	#define INS_B CHOICE(insb, insb, insb)	455	#define INS_B CHOICE(insb, insb, insb)
462	#define INT(a) CHOICE(int a, int a, int a)	456	#define INT(a) CHOICE(int a, int a, int a)
463	#define INT3 CHOICE(int CONST(3), int3, int CONST(3))	457	#define INT3 CHOICE(int CONST(3), int3, int CONST(3))
464	#define INTO CHOICE(into, into, into)	458	#define INTO CHOICE(into, into, into)
465	#define IRET CHOICE(iret, iret, iret)	459	#define IRET CHOICE(iret, iret, iret)
466	#define IRETD CHOICE(iret, iret, iretd)	460	#define IRETD CHOICE(iret, iret, iretd)
467	#define JA(a) CHOICE(ja a, ja a, ja a)	461	#define JA(a) CHOICE(ja a, ja a, ja a)
468	#define JAE(a) CHOICE(jae a, jae a, jae a)	462	#define JAE(a) CHOICE(jae a, jae a, jae a)
469	#define JB(a) CHOICE(jb a, jb a, jb a)	463	#define JB(a) CHOICE(jb a, jb a, jb a)
470	#define JBE(a) CHOICE(jbe a, jbe a, jbe a)	464	#define JBE(a) CHOICE(jbe a, jbe a, jbe a)
471	#define JC(a) CHOICE(jc a, jc a, jc a)	465	#define JC(a) CHOICE(jc a, jc a, jc a)
472	#define JE(a) CHOICE(je a, je a, je a)	466	#define JE(a) CHOICE(je a, je a, je a)
473	#define JG(a) CHOICE(jg a, jg a, jg a)	467	#define JG(a) CHOICE(jg a, jg a, jg a)
474	#define JGE(a) CHOICE(jge a, jge a, jge a)	468	#define JGE(a) CHOICE(jge a, jge a, jge a)
475	#define JL(a) CHOICE(jl a, jl a, jl a)	469	#define JL(a) CHOICE(jl a, jl a, jl a)
476	#define JLE(a) CHOICE(jle a, jle a, jle a)	470	#define JLE(a) CHOICE(jle a, jle a, jle a)
477	#define JNA(a) CHOICE(jna a, jna a, jna a)	471	#define JNA(a) CHOICE(jna a, jna a, jna a)
478	#define JNAE(a) CHOICE(jnae a, jnae a, jnae a)	472	#define JNAE(a) CHOICE(jnae a, jnae a, jnae a)
479	#define JNB(a) CHOICE(jnb a, jnb a, jnb a)	473	#define JNB(a) CHOICE(jnb a, jnb a, jnb a)
480	#define JNBE(a) CHOICE(jnbe a, jnbe a, jnbe a)	474	#define JNBE(a) CHOICE(jnbe a, jnbe a, jnbe a)
481	#define JNC(a) CHOICE(jnc a, jnc a, jnc a)	475	#define JNC(a) CHOICE(jnc a, jnc a, jnc a)
482	#define JNE(a) CHOICE(jne a, jne a, jne a)	476	#define JNE(a) CHOICE(jne a, jne a, jne a)
483	#define JNG(a) CHOICE(jng a, jng a, jng a)	477	#define JNG(a) CHOICE(jng a, jng a, jng a)
484	#define JNGE(a) CHOICE(jnge a, jnge a, jnge a)	478	#define JNGE(a) CHOICE(jnge a, jnge a, jnge a)
485	#define JNL(a) CHOICE(jnl a, jnl a, jnl a)	479	#define JNL(a) CHOICE(jnl a, jnl a, jnl a)
486	#define JNLE(a) CHOICE(jnle a, jnle a, jnle a)	480	#define JNLE(a) CHOICE(jnle a, jnle a, jnle a)
487	#define JNO(a) CHOICE(jno a, jno a, jno a)	481	#define JNO(a) CHOICE(jno a, jno a, jno a)
488	#define JNP(a) CHOICE(jnp a, jnp a, jnp a)	482	#define JNP(a) CHOICE(jnp a, jnp a, jnp a)
489	#define JNS(a) CHOICE(jns a, jns a, jns a)	483	#define JNS(a) CHOICE(jns a, jns a, jns a)
490	#define JNZ(a) CHOICE(jnz a, jnz a, jnz a)	484	#define JNZ(a) CHOICE(jnz a, jnz a, jnz a)
491	#define JO(a) CHOICE(jo a, jo a, jo a)	485	#define JO(a) CHOICE(jo a, jo a, jo a)
492	#define JP(a) CHOICE(jp a, jp a, jp a)	486	#define JP(a) CHOICE(jp a, jp a, jp a)
493	#define JPE(a) CHOICE(jpe a, jpe a, jpe a)	487	#define JPE(a) CHOICE(jpe a, jpe a, jpe a)
494	#define JPO(a) CHOICE(jpo a, jpo a, jpo a)	488	#define JPO(a) CHOICE(jpo a, jpo a, jpo a)
495	#define JS(a) CHOICE(js a, js a, js a)	489	#define JS(a) CHOICE(js a, js a, js a)
496	#define JZ(a) CHOICE(jz a, jz a, jz a)	490	#define JZ(a) CHOICE(jz a, jz a, jz a)
497	#define JMP(a) CHOICE(jmp a, jmp a, jmp a)	491	#define JMP(a) CHOICE(jmp a, jmp a, jmp a)
498	#define JMPF(s,a) CHOICE(ljmp ARG2(s,a), ljmp ARG2(s,a), jmpf s:a)	492	#define JMPF(s,a) CHOICE(ljmp ARG2(s,a), ljmp ARG2(s,a), jmpf s:a)
499	#define LAHF CHOICE(lahf, lahf, lahf)	493	#define LAHF CHOICE(lahf, lahf, lahf)
500	#if !defined(_REAL_MODE) && !defined(_V86_MODE)	494	#if !defined(_REAL_MODE) && !defined(_V86_MODE)

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/Mesa/src/mesa/x86/assyntax.h – Rev 4358 → 5063