Subversion Repositories shark

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
70 giacomo 1
/* $Id: assyntax.h,v 1.1 2003-03-13 12:11:48 giacomo Exp $ */
2
 
3
#ifndef __ASSYNTAX_H__
4
#define __ASSYNTAX_H__
5
 
6
/*
7
 * Copyright 1992 Vrije Universiteit, The Netherlands
8
 *
9
 * Permission to use, copy, modify, and distribute this software and its
10
 * documentation for any purpose and without fee is hereby granted, provided
11
 * that the above copyright notice appear in all copies and that both that
12
 * copyright notice and this permission notice appear in supporting
13
 * documentation, and that the name of the Vrije Universiteit not be used in
14
 * advertising or publicity pertaining to distribution of the software without
15
 * specific, written prior permission.  The Vrije Universiteit makes no
16
 * representations about the suitability of this software for any purpose.
17
 * It is provided "as is" without express or implied warranty.
18
 *
19
 * The Vrije Universiteit DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
20
 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
21
 * IN NO EVENT SHALL The Vrije Universiteit BE LIABLE FOR ANY SPECIAL,
22
 * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
23
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
24
 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
25
 * PERFORMANCE OF THIS SOFTWARE.
26
 */
27
 
28
/*
29
 * assyntax.h
30
 *
31
 * Select the syntax appropriate to the 386 assembler being used
32
 * To add support for more assemblers add more columns to the CHOICE
33
 * macro.  Note that register names must also have uppercase names
34
 * to avoid macro recursion. e.g., #define ah %ah recurses!
35
 *
36
 * NB 1.  Some of the macros for certain assemblers imply that the code is to
37
 *        run in protected mode!!  Caveat emptor.
38
 *
39
 * NB 2.  486 specific instructions are not included.  This is to discourage
40
 *        their accidental use in code that is intended to run on 386 and 486
41
 *        systems.
42
 *
43
 * Supported assemblers:
44
 *
45
 * (a) AT&T SysVr4 as(1):       define ATT_ASSEMBLER
46
 * (b) GNU Assembler gas:       define GNU_ASSEMBLER (default)
47
 * (c) Amsterdam Compiler kit:  define ACK_ASSEMBLER
48
 * (d) The Netwide Assembler:   define NASM_ASSEMBLER
49
 * (e) Microsoft Assembler:     define MASM_ASSEMBLER (UNTESTED!)
50
 *
51
 * The following naming conventions have been used to identify the various
52
 * data types:
53
 *              _SR = segment register version
54
 *      Integer:
55
 *              _Q = quadword   = 64 bits
56
 *              _L = long       = 32 bits
57
 *              _W = short      = 16 bits
58
 *              _B = byte       =  8 bits
59
 *      Floating-point:
60
 *              _X = m80real    = 80 bits
61
 *              _D = double     = 64 bits
62
 *              _S = single     = 32 bits
63
 *
64
 * Author: Gregory J. Sharp, Sept 1992
65
 *         Vrije Universiteit, Amsterdam, The Netherlands
66
 *
67
 *         [support for Intel syntax added by Josh Vanderhoof, 1999]
68
 */
69
 
70
#if !(defined(NASM_ASSEMBLER) || defined(MASM_ASSEMBLER))
71
 
72
/* Default to ATT_ASSEMBLER when SVR4 or SYSV are defined */
73
#if (defined(SVR4) || defined(SYSV)) && !defined(GNU_ASSEMBLER)
74
#define ATT_ASSEMBLER
75
#endif
76
 
77
#if !defined(ATT_ASSEMBLER) && !defined(GNU_ASSEMBLER) && !defined(ACK_ASSEMBLER)
78
#define GNU_ASSEMBLER
79
#endif
80
 
81
#if (defined(__STDC__) && !defined(UNIXCPP)) || (defined (sun) && defined (i386) && defined (SVR4) && defined (__STDC__) && !defined (__GNUC__))
82
#define CONCAT(x, y)    x ## y
83
#else
84
#define CONCAT(x, y)    x/**/y
85
#endif
86
 
87
#ifdef ACK_ASSEMBLER
88
 
89
/* Assume we write code for 32-bit protected mode! */
90
 
91
/* Redefine register names for GAS & AT&T assemblers */
92
#define AL              al
93
#define AH              ah
94
#define AX              ax
95
#define EAX             ax
96
#define BL              bl
97
#define BH              bh
98
#define BX              bx
99
#define EBX             bx
100
#define CL              cl
101
#define CH              ch
102
#define CX              cx
103
#define ECX             cx
104
#define DL              dl
105
#define DH              dh
106
#define DX              dx
107
#define EDX             dx
108
#define BP              bp
109
#define EBP             bp
110
#define SI              si
111
#define ESI             si
112
#define DI              di
113
#define EDI             di
114
#define SP              sp
115
#define ESP             sp
116
#define CS              cs
117
#define SS              ss
118
#define DS              ds
119
#define ES              es
120
#define FS              fs
121
#define GS              gs
122
/* Control Registers */
123
#define CR0             cr0
124
#define CR1             cr1
125
#define CR2             cr2
126
#define CR3             cr3
127
/* Debug Registers */
128
#define DR0             dr0
129
#define DR1             dr1
130
#define DR2             dr2
131
#define DR3             dr3
132
#define DR4             dr4
133
#define DR5             dr5
134
#define DR6             dr6
135
#define DR7             dr7
136
/* Floating-point Stack */
137
#define ST              st
138
 
139
#define AS_BEGIN        .sect .text; .sect .rom; .sect .data; .sect .bss; .sect .text
140
 
141
 
142
#define _WTOG           o16     /* word toggle for _W instructions */
143
#define _LTOG                   /* long toggle for _L instructions */
144
#define ADDR_TOGGLE     a16
145
#define OPSZ_TOGGLE     o16
146
#define USE16           .use16
147
#define USE32           .use32
148
 
149
#define CHOICE(a,b,c)   c
150
 
151
#else /* AT&T or GAS */
152
 
153
/* Redefine register names for GAS & AT&T assemblers */
154
#define AL              %al
155
#define AH              %ah
156
#define AX              %ax
157
#define EAX             %eax
158
#define BL              %bl
159
#define BH              %bh
160
#define BX              %bx
161
#define EBX             %ebx
162
#define CL              %cl
163
#define CH              %ch
164
#define CX              %cx
165
#define ECX             %ecx
166
#define DL              %dl
167
#define DH              %dh
168
#define DX              %dx
169
#define EDX             %edx
170
#define BP              %bp
171
#define EBP             %ebp
172
#define SI              %si
173
#define ESI             %esi
174
#define DI              %di
175
#define EDI             %edi
176
#define SP              %sp
177
#define ESP             %esp
178
#define CS              %cs
179
#define SS              %ss
180
#define DS              %ds
181
#define ES              %es
182
#define FS              %fs
183
#define GS              %gs
184
/* Control Registers */
185
#define CR0             %cr0
186
#define CR1             %cr1
187
#define CR2             %cr2
188
#define CR3             %cr3
189
/* Debug Registers */
190
#define DR0             %db0
191
#define DR1             %db1
192
#define DR2             %db2
193
#define DR3             %db3
194
#define DR4             %db4
195
#define DR5             %db5
196
#define DR6             %db6
197
#define DR7             %db7
198
/* Floating-point Stack */
199
#define _STX0           %st(0)
200
#define _STX1           %st(1)
201
#define _STX2           %st(2)
202
#define _STX3           %st(3)
203
#define _STX4           %st(4)
204
#define _STX5           %st(5)
205
#define _STX6           %st(6)
206
#define _STX7           %st(7)
207
#define ST(x)           CONCAT(_STX,x)
208
#ifdef GNU_ASSEMBLER
209
#define ST0             %st(0)
210
#else
211
#define ST0             %st
212
#endif
213
/* MMX Registers */
214
#define MM0             %mm0
215
#define MM1             %mm1
216
#define MM2             %mm2
217
#define MM3             %mm3
218
#define MM4             %mm4
219
#define MM5             %mm5
220
#define MM6             %mm6
221
#define MM7             %mm7
222
/* SSE Registers */
223
#define XMM0            %xmm0
224
#define XMM1            %xmm1
225
#define XMM2            %xmm2
226
#define XMM3            %xmm3
227
#define XMM4            %xmm4
228
#define XMM5            %xmm5
229
#define XMM6            %xmm6
230
#define XMM7            %xmm7
231
 
232
#define AS_BEGIN
233
#define USE16
234
#define USE32
235
 
236
#ifdef GNU_ASSEMBLER
237
 
238
#define ADDR_TOGGLE     aword
239
#define OPSZ_TOGGLE     word
240
 
241
#define CHOICE(a,b,c)   b
242
 
243
#else
244
/*
245
 * AT&T ASSEMBLER SYNTAX
246
 * *********************
247
 */
248
#define CHOICE(a,b,c)   a
249
 
250
#define ADDR_TOGGLE     addr16
251
#define OPSZ_TOGGLE     data16
252
 
253
#endif /* GNU_ASSEMBLER */
254
#endif /* ACK_ASSEMBLER */
255
 
256
 
257
#if defined(__QNX__) || defined(Lynx) || (defined(SYSV) || defined(SVR4)) && !defined(ACK_ASSEMBLER) || defined(__ELF__) || defined(__GNU__) || defined(__GNUC__) && !defined(DJGPP)
258
#define GLNAME(a)       a
259
#else
260
#define GLNAME(a)       CONCAT(_,a)
261
#endif
262
 
263
 
264
        /****************************************/
265
        /*                                      */
266
        /*      Select the various choices      */
267
        /*                                      */
268
        /****************************************/
269
 
270
 
271
/* Redefine assembler directives */
272
/*********************************/
273
#define GLOBL           CHOICE(.globl, .globl, .extern)
274
#define GLOBAL          GLOBL
275
#define EXTERN          GLOBL
276
/*
277
#define ALIGNTEXT32     CHOICE(.align 32, .align ARG2(5,0x90), .align 32)
278
*/
279
#define ALIGNTEXT32     CHOICE(.align 32, .balign 32, .align 32)
280
#define ALIGNTEXT16     CHOICE(.align 16, .balign 16, .align 16)
281
#define ALIGNTEXT8      CHOICE(.align 8, .balign 8, .align 8)
282
#define ALIGNTEXT4      CHOICE(.align 4, .balign 4, .align 4)
283
#define ALIGNTEXT2      CHOICE(.align 2, .balign 2, .align 2)
284
/* ALIGNTEXT4ifNOP is the same as ALIGNTEXT4, but only if the space is
285
 * guaranteed to be filled with NOPs.  Otherwise it does nothing.
286
 */
287
#define ALIGNTEXT32ifNOP        CHOICE(.align 32, .balign ARG2(32,0x90), /*can't do it*/)
288
#define ALIGNTEXT16ifNOP        CHOICE(.align 16, .balign ARG2(16,0x90), /*can't do it*/)
289
#define ALIGNTEXT8ifNOP CHOICE(.align 8, .balign ARG2(8,0x90), /*can't do it*/)
290
#define ALIGNTEXT4ifNOP CHOICE(.align 4, .balign ARG2(4,0x90), /*can't do it*/)
291
#define ALIGNDATA32     CHOICE(.align 32, .balign ARG2(32,0x0), .align 32)
292
#define ALIGNDATA16     CHOICE(.align 16, .balign ARG2(16,0x0), .align 16)
293
#define ALIGNDATA8      CHOICE(.align 8, .balign ARG2(8,0x0), .align 8)
294
#define ALIGNDATA4      CHOICE(.align 4, .balign ARG2(4,0x0), .align 4)
295
#define ALIGNDATA2      CHOICE(.align 2, .balign ARG2(2,0x0), .align 2)
296
#define FILE(s)         CHOICE(.file s, .file s, .file s)
297
#define STRING(s)       CHOICE(.string s, .asciz s, .asciz s)
298
#define D_LONG          CHOICE(.long, .long, .data4)
299
#define D_WORD          CHOICE(.value, .short, .data2)
300
#define D_BYTE          CHOICE(.byte, .byte, .data1)
301
#define SPACE           CHOICE(.comm, .space, .space)
302
#define COMM            CHOICE(.comm, .comm, .comm)
303
#define SEG_DATA        CHOICE(.data, .data, .sect .data)
304
#define SEG_TEXT        CHOICE(.text, .text, .sect .text)
305
#define SEG_BSS         CHOICE(.bss, .bss, .sect .bss)
306
 
307
#ifdef GNU_ASSEMBLER
308
#define D_SPACE(n)      . = . + n
309
#else
310
#define D_SPACE(n)      .space n
311
#endif
312
 
313
/* Addressing Modes */
314
/* Immediate Mode */
315
#define ADDR(a)         CHOICE(CONCAT($,a), CONCAT($,a), a)
316
#define CONST(a)        CHOICE(CONCAT($,a), CONCAT($,a), a)
317
 
318
/* Indirect Mode */
319
#define CONTENT(a)      CHOICE(a, a, (a))        /* take contents of variable */
320
#define REGIND(a)       CHOICE((a), (a), (a))    /* Register a indirect */
321
/* Register b indirect plus displacement a */
322
#define REGOFF(a, b)    CHOICE(a(b), a(b), a(b))
323
/* Reg indirect Base + Index + Displacement  - this is mainly for 16-bit mode
324
 * which has no scaling
325
 */
326
#define REGBID(b,i,d)   CHOICE(d(b,i), d(b,i), d(b)(i))
327
/* Reg indirect Base + (Index * Scale) */
328
#define REGBIS(b,i,s)   CHOICE((b,i,s), (b,i,s), (b)(i*s))
329
/* Reg indirect Base + (Index * Scale) + Displacement */
330
#define REGBISD(b,i,s,d) CHOICE(d(b,i,s), d(b,i,s), d(b)(i*s))
331
/* Displaced Scaled Index: */
332
#define REGDIS(d,i,s)   CHOICE(d(,i,s), d(,i,s), d(i * s))
333
/* Indexed Base: */
334
#define REGBI(b,i)      CHOICE((b,i), (b,i), (b)(i))
335
/* Displaced Base: */
336
#define REGDB(d,b)      CHOICE(d(b), d(b), d(b))
337
/* Variable indirect: */
338
#define VARINDIRECT(var) CHOICE(*var, *var, (var))
339
/* Use register contents as jump/call target: */
340
#define CODEPTR(reg)    CHOICE(*reg, *reg, reg)
341
 
342
/* For expressions requiring bracketing
343
 * eg. (CRT0_PM | CRT_EM)
344
 */
345
 
346
#define EXPR(a)         CHOICE([a], (a), [a])
347
#define ENOT(a)         CHOICE(0!a, ~a, ~a)
348
#define EMUL(a,b)       CHOICE(a\*b, a*b, a*b)
349
#define EDIV(a,b)       CHOICE(a\/b, a/b, a/b)
350
 
351
/*
352
 * We have to beat the problem of commas within arguments to choice.
353
 * eg. choice (add a,b, add b,a) will get argument mismatch.  Luckily ANSI
354
 * and other known cpp definitions evaluate arguments before substitution
355
 * so the following works.
356
 */
357
#define ARG2(a, b)      a,b
358
#define ARG3(a,b,c)     a,b,c
359
 
360
/* Redefine assembler commands */
361
#define AAA             CHOICE(aaa, aaa, aaa)
362
#define AAD             CHOICE(aad, aad, aad)
363
#define AAM             CHOICE(aam, aam, aam)
364
#define AAS             CHOICE(aas, aas, aas)
365
#define ADC_L(a, b)     CHOICE(adcl ARG2(a,b), adcl ARG2(a,b), _LTOG adc ARG2(b,a))
366
#define ADC_W(a, b)     CHOICE(adcw ARG2(a,b), adcw ARG2(a,b), _WTOG adc ARG2(b,a))
367
#define ADC_B(a, b)     CHOICE(adcb ARG2(a,b), adcb ARG2(a,b), adcb ARG2(b,a))
368
#define ADD_L(a, b)     CHOICE(addl ARG2(a,b), addl ARG2(a,b), _LTOG add ARG2(b,a))
369
#define ADD_W(a, b)     CHOICE(addw ARG2(a,b), addw ARG2(a,b), _WTOG add ARG2(b,a))
370
#define ADD_B(a, b)     CHOICE(addb ARG2(a,b), addb ARG2(a,b), addb ARG2(b,a))
371
#define AND_L(a, b)     CHOICE(andl ARG2(a,b), andl ARG2(a,b), _LTOG and ARG2(b,a))
372
#define AND_W(a, b)     CHOICE(andw ARG2(a,b), andw ARG2(a,b), _WTOG and ARG2(b,a))
373
#define AND_B(a, b)     CHOICE(andb ARG2(a,b), andb ARG2(a,b), andb ARG2(b,a))
374
#define ARPL(a,b)       CHOICE(arpl ARG2(a,b), arpl ARG2(a,b), arpl ARG2(b,a))
375
#define BOUND_L(a, b)   CHOICE(boundl ARG2(a,b), boundl ARG2(b,a), _LTOG bound ARG2(b,a))
376
#define BOUND_W(a, b)   CHOICE(boundw ARG2(a,b), boundw ARG2(b,a), _WTOG bound ARG2(b,a))
377
#define BSF_L(a, b)     CHOICE(bsfl ARG2(a,b), bsfl ARG2(a,b), _LTOG bsf ARG2(b,a))
378
#define BSF_W(a, b)     CHOICE(bsfw ARG2(a,b), bsfw ARG2(a,b), _WTOG bsf ARG2(b,a))
379
#define BSR_L(a, b)     CHOICE(bsrl ARG2(a,b), bsrl ARG2(a,b), _LTOG bsr ARG2(b,a))
380
#define BSR_W(a, b)     CHOICE(bsrw ARG2(a,b), bsrw ARG2(a,b), _WTOG bsr ARG2(b,a))
381
#define BT_L(a, b)      CHOICE(btl ARG2(a,b), btl ARG2(a,b), _LTOG bt ARG2(b,a))
382
#define BT_W(a, b)      CHOICE(btw ARG2(a,b), btw ARG2(a,b), _WTOG bt ARG2(b,a))
383
#define BTC_L(a, b)     CHOICE(btcl ARG2(a,b), btcl ARG2(a,b), _LTOG btc ARG2(b,a))
384
#define BTC_W(a, b)     CHOICE(btcw ARG2(a,b), btcw ARG2(a,b), _WTOG btc ARG2(b,a))
385
#define BTR_L(a, b)     CHOICE(btrl ARG2(a,b), btrl ARG2(a,b), _LTOG btr ARG2(b,a))
386
#define BTR_W(a, b)     CHOICE(btrw ARG2(a,b), btrw ARG2(a,b), _WTOG btr ARG2(b,a))
387
#define BTS_L(a, b)     CHOICE(btsl ARG2(a,b), btsl ARG2(a,b), _LTOG bts ARG2(b,a))
388
#define BTS_W(a, b)     CHOICE(btsw ARG2(a,b), btsw ARG2(a,b), _WTOG bts ARG2(b,a))
389
#define CALL(a)         CHOICE(call a, call a, call a)
390
#define CALLF(s,a)      CHOICE(lcall ARG2(s,a), lcall ARG2(s,a), callf s:a)
391
#define CBW             CHOICE(cbtw, cbw, cbw)
392
#define CWDE            CHOICE(cwtd, cwde, cwde)
393
#define CLC             CHOICE(clc, clc, clc)
394
#define CLD             CHOICE(cld, cld, cld)
395
#define CLI             CHOICE(cli, cli, cli)
396
#define CLTS            CHOICE(clts, clts, clts)
397
#define CMC             CHOICE(cmc, cmc, cmc)
398
#define CMP_L(a, b)     CHOICE(cmpl ARG2(a,b), cmpl ARG2(a,b), _LTOG cmp ARG2(b,a))
399
#define CMP_W(a, b)     CHOICE(cmpw ARG2(a,b), cmpw ARG2(a,b), _WTOG cmp ARG2(b,a))
400
#define CMP_B(a, b)     CHOICE(cmpb ARG2(a,b), cmpb ARG2(a,b), cmpb ARG2(b,a))
401
#define CMPS_L          CHOICE(cmpsl, cmpsl, _LTOG cmps)
402
#define CMPS_W          CHOICE(cmpsw, cmpsw, _WTOG cmps)
403
#define CMPS_B          CHOICE(cmpsb, cmpsb, cmpsb)
404
#define CWD             CHOICE(cwtl, cwd, cwd)
405
#define CDQ             CHOICE(cltd, cdq, cdq)
406
#define DAA             CHOICE(daa, daa, daa)
407
#define DAS             CHOICE(das, das, das)
408
#define DEC_L(a)        CHOICE(decl a, decl a, _LTOG dec a)
409
#define DEC_W(a)        CHOICE(decw a, decw a, _WTOG dec a)
410
#define DEC_B(a)        CHOICE(decb a, decb a, decb a)
411
#define DIV_L(a)        CHOICE(divl a, divl a, div a)
412
#define DIV_W(a)        CHOICE(divw a, divw a, div a)
413
#define DIV_B(a)        CHOICE(divb a, divb a, divb a)
414
#define ENTER(a,b)      CHOICE(enter ARG2(a,b), enter ARG2(a,b), enter ARG2(b,a))
415
#define HLT             CHOICE(hlt, hlt, hlt)
416
#define IDIV_L(a)       CHOICE(idivl a, idivl a, _LTOG idiv a)
417
#define IDIV_W(a)       CHOICE(idivw a, idivw a, _WTOG idiv a)
418
#define IDIV_B(a)       CHOICE(idivb a, idivb a, idivb a)
419
/* More forms than this for imul!! */
420
#define IMUL_L(a, b)    CHOICE(imull ARG2(a,b), imull ARG2(a,b), _LTOG imul ARG2(b,a))
421
#define IMUL_W(a, b)    CHOICE(imulw ARG2(a,b), imulw ARG2(a,b), _WTOG imul ARG2(b,a))
422
#define IMUL_B(a)       CHOICE(imulb a, imulb a, imulb a)
423
#define IN_L            CHOICE(inl (DX), inl ARG2(DX,EAX), _LTOG in DX)
424
#define IN_W            CHOICE(inw (DX), inw ARG2(DX,AX), _WTOG in DX)
425
#define IN_B            CHOICE(inb (DX), inb ARG2(DX,AL), inb DX)
426
/* Please AS code writer: use the following ONLY, if you refer to ports<256
427
 * directly, but not in IN1_W(DX), for instance, even if IN1_ looks nicer
428
 */
429
#if defined (sun)
430
#define IN1_L(a)        CHOICE(inl (a), inl ARG2(a,EAX), _LTOG in a)
431
#define IN1_W(a)        CHOICE(inw (a), inw ARG2(a,AX), _WTOG in a)
432
#define IN1_B(a)        CHOICE(inb (a), inb ARG2(a,AL), inb a)
433
#else
434
#define IN1_L(a)        CHOICE(inl a, inl ARG2(a,EAX), _LTOG in a)
435
#define IN1_W(a)        CHOICE(inw a, inw ARG2(a,AX), _WTOG in a)
436
#define IN1_B(a)        CHOICE(inb a, inb ARG2(a,AL), inb a)
437
#endif
438
#define INC_L(a)        CHOICE(incl a, incl a, _LTOG inc a)
439
#define INC_W(a)        CHOICE(incw a, incw a, _WTOG inc a)
440
#define INC_B(a)        CHOICE(incb a, incb a, incb a)
441
#define INS_L           CHOICE(insl, insl, _LTOG ins)
442
#define INS_W           CHOICE(insw, insw, _WTOG ins)
443
#define INS_B           CHOICE(insb, insb, insb)
444
#define INT(a)          CHOICE(int a, int a, int a)
445
#define INT3            CHOICE(int CONST(3), int3, int CONST(3))
446
#define INTO            CHOICE(into, into, into)
447
#define IRET            CHOICE(iret, iret, iret)
448
#define IRETD           CHOICE(iret, iret, iretd)
449
#define JA(a)           CHOICE(ja a, ja a, ja a)
450
#define JAE(a)          CHOICE(jae a, jae a, jae a)
451
#define JB(a)           CHOICE(jb a, jb a, jb a)
452
#define JBE(a)          CHOICE(jbe a, jbe a, jbe a)
453
#define JC(a)           CHOICE(jc a, jc a, jc a)
454
#define JE(a)           CHOICE(je a, je a, je a)
455
#define JG(a)           CHOICE(jg a, jg a, jg a)
456
#define JGE(a)          CHOICE(jge a, jge a, jge a)
457
#define JL(a)           CHOICE(jl a, jl a, jl a)
458
#define JLE(a)          CHOICE(jle a, jle a, jle a)
459
#define JNA(a)          CHOICE(jna a, jna a, jna a)
460
#define JNAE(a)         CHOICE(jnae a, jnae a, jnae a)
461
#define JNB(a)          CHOICE(jnb a, jnb a, jnb a)
462
#define JNBE(a)         CHOICE(jnbe a, jnbe a, jnbe a)
463
#define JNC(a)          CHOICE(jnc a, jnc a, jnc a)
464
#define JNE(a)          CHOICE(jne a, jne a, jne a)
465
#define JNG(a)          CHOICE(jng a, jng a, jng a)
466
#define JNGE(a)         CHOICE(jnge a, jnge a, jnge a)
467
#define JNL(a)          CHOICE(jnl a, jnl a, jnl a)
468
#define JNLE(a)         CHOICE(jnle a, jnle a, jnle a)
469
#define JNO(a)          CHOICE(jno a, jno a, jno a)
470
#define JNP(a)          CHOICE(jnp a, jnp a, jnp a)
471
#define JNS(a)          CHOICE(jns a, jns a, jns a)
472
#define JNZ(a)          CHOICE(jnz a, jnz a, jnz a)
473
#define JO(a)           CHOICE(jo a, jo a, jo a)
474
#define JP(a)           CHOICE(jp a, jp a, jp a)
475
#define JPE(a)          CHOICE(jpe a, jpe a, jpe a)
476
#define JPO(a)          CHOICE(jpo a, jpo a, jpo a)
477
#define JS(a)           CHOICE(js a, js a, js a)
478
#define JZ(a)           CHOICE(jz a, jz a, jz a)
479
#define JMP(a)          CHOICE(jmp a, jmp a, jmp a)
480
#define JMPF(s,a)       CHOICE(ljmp ARG2(s,a), ljmp ARG2(s,a), jmpf s:a)
481
#define LAHF            CHOICE(lahf, lahf, lahf)
482
#if !defined(_REAL_MODE) && !defined(_V86_MODE)
483
#define LAR(a, b)       CHOICE(lar ARG2(a, b), lar ARG2(a, b), lar ARG2(b, a))
484
#endif
485
#define LEA_L(a, b)     CHOICE(leal ARG2(a,b), leal ARG2(a,b), _LTOG lea ARG2(b,a))
486
#define LEA_W(a, b)     CHOICE(leaw ARG2(a,b), leaw ARG2(a,b), _WTOG lea ARG2(b,a))
487
#define LEAVE           CHOICE(leave, leave, leave)
488
#define LGDT(a)         CHOICE(lgdt a, lgdt a, lgdt a)
489
#define LIDT(a)         CHOICE(lidt a, lidt a, lidt a)
490
#define LDS(a, b)       CHOICE(ldsl ARG2(a,b), lds ARG2(a,b), lds ARG2(b,a))
491
#define LES(a, b)       CHOICE(lesl ARG2(a,b), les ARG2(a,b), les ARG2(b,a))
492
#define LFS(a, b)       CHOICE(lfsl ARG2(a,b), lfs ARG2(a,b), lfs ARG2(b,a))
493
#define LGS(a, b)       CHOICE(lgsl ARG2(a,b), lgs ARG2(a,b), lgs ARG2(b,a))
494
#define LSS(a, b)       CHOICE(lssl ARG2(a,b), lss ARG2(a,b), lss ARG2(b,a))
495
#define LLDT(a)         CHOICE(lldt a, lldt a, lldt a)
496
#define LMSW(a)         CHOICE(lmsw a, lmsw a, lmsw a)
497
#define LOCK            CHOICE(lock, lock, lock)
498
#define LODS_L          CHOICE(lodsl, lodsl, _LTOG lods)
499
#define LODS_W          CHOICE(lodsw, lodsw, _WTOG lods)
500
#define LODS_B          CHOICE(lodsb, lodsb, lodsb)
501
#define LOOP(a)         CHOICE(loop a, loop a, loop a)
502
#define LOOPE(a)        CHOICE(loope a, loope a, loope a)
503
#define LOOPZ(a)        CHOICE(loopz a, loopz a, loopz a)
504
#define LOOPNE(a)       CHOICE(loopne a, loopne a, loopne a)
505
#define LOOPNZ(a)       CHOICE(loopnz a, loopnz a, loopnz a)
506
#if !defined(_REAL_MODE) && !defined(_V86_MODE)
507
#define LSL(a, b)       CHOICE(lsl ARG2(a,b), lsl ARG2(a,b), lsl ARG2(b,a))
508
#endif
509
#define LTR(a)          CHOICE(ltr a, ltr a, ltr a)
510
#define MOV_SR(a, b)    CHOICE(movw ARG2(a,b), mov ARG2(a,b), mov ARG2(b,a))
511
#define MOV_L(a, b)     CHOICE(movl ARG2(a,b), movl ARG2(a,b), _LTOG mov ARG2(b,a))
512
#define MOV_W(a, b)     CHOICE(movw ARG2(a,b), movw ARG2(a,b), _WTOG mov ARG2(b,a))
513
#define MOV_B(a, b)     CHOICE(movb ARG2(a,b), movb ARG2(a,b), movb ARG2(b,a))
514
#define MOVS_L          CHOICE(movsl, movsl, _LTOG movs)
515
#define MOVS_W          CHOICE(movsw, movsw, _WTOG movs)
516
#define MOVS_B          CHOICE(movsb, movsb, movsb)
517
#define MOVSX_BL(a, b)  CHOICE(movsbl ARG2(a,b), movsbl ARG2(a,b), movsx ARG2(b,a))
518
#define MOVSX_BW(a, b)  CHOICE(movsbw ARG2(a,b), movsbw ARG2(a,b), movsx ARG2(b,a))
519
#define MOVSX_WL(a, b)  CHOICE(movswl ARG2(a,b), movswl ARG2(a,b), movsx ARG2(b,a))
520
#define MOVZX_BL(a, b)  CHOICE(movzbl ARG2(a,b), movzbl ARG2(a,b), movzx ARG2(b,a))
521
#define MOVZX_BW(a, b)  CHOICE(movzbw ARG2(a,b), movzbw ARG2(a,b), movzx ARG2(b,a))
522
#define MOVZX_WL(a, b)  CHOICE(movzwl ARG2(a,b), movzwl ARG2(a,b), movzx ARG2(b,a))
523
#define MUL_L(a)        CHOICE(mull a, mull a, _LTOG mul a)
524
#define MUL_W(a)        CHOICE(mulw a, mulw a, _WTOG mul a)
525
#define MUL_B(a)        CHOICE(mulb a, mulb a, mulb a)
526
#define NEG_L(a)        CHOICE(negl a, negl a, _LTOG neg a)
527
#define NEG_W(a)        CHOICE(negw a, negw a, _WTOG neg a)
528
#define NEG_B(a)        CHOICE(negb a, negb a, negb a)
529
#define NOP             CHOICE(nop, nop, nop)
530
#define NOT_L(a)        CHOICE(notl a, notl a, _LTOG not a)
531
#define NOT_W(a)        CHOICE(notw a, notw a, _WTOG not a)
532
#define NOT_B(a)        CHOICE(notb a, notb a, notb a)
533
#define OR_L(a,b)       CHOICE(orl ARG2(a,b), orl ARG2(a,b), _LTOG or ARG2(b,a))
534
#define OR_W(a,b)       CHOICE(orw ARG2(a,b), orw ARG2(a,b), _WTOG or ARG2(b,a))
535
#define OR_B(a,b)       CHOICE(orb ARG2(a,b), orb ARG2(a,b), orb ARG2(b,a))
536
#define OUT_L           CHOICE(outl (DX), outl ARG2(EAX,DX), _LTOG out DX)
537
#define OUT_W           CHOICE(outw (DX), outw ARG2(AX,DX), _WTOG out DX)
538
#define OUT_B           CHOICE(outb (DX), outb ARG2(AL,DX), outb DX)
539
/* Please AS code writer: use the following ONLY, if you refer to ports<256
540
 * directly, but not in OUT1_W(DX), for instance, even if OUT1_ looks nicer
541
 */
542
#define OUT1_L(a)       CHOICE(outl (a), outl ARG2(EAX,a), _LTOG out a)
543
#define OUT1_W(a)       CHOICE(outw (a), outw ARG2(AX,a), _WTOG out a)
544
#define OUT1_B(a)       CHOICE(outb (a), outb ARG2(AL,a), outb a)
545
#define OUTS_L          CHOICE(outsl, outsl, _LTOG outs)
546
#define OUTS_W          CHOICE(outsw, outsw, _WTOG outs)
547
#define OUTS_B          CHOICE(outsb, outsb, outsb)
548
#define POP_SR(a)       CHOICE(pop a, pop a, pop a)
549
#define POP_L(a)        CHOICE(popl a, popl a, _LTOG pop a)
550
#define POP_W(a)        CHOICE(popw a, popw a, _WTOG pop a)
551
#define POPA_L          CHOICE(popal, popal, _LTOG popa)
552
#define POPA_W          CHOICE(popaw, popaw, _WTOG popa)
553
#define POPF_L          CHOICE(popfl, popfl, _LTOG popf)
554
#define POPF_W          CHOICE(popfw, popfw, _WTOG popf)
555
#define PUSH_SR(a)      CHOICE(push a, push a, push a)
556
#define PUSH_L(a)       CHOICE(pushl a, pushl a, _LTOG push a)
557
#define PUSH_W(a)       CHOICE(pushw a, pushw a, _WTOG push a)
558
#define PUSH_B(a)       CHOICE(push a, pushb a, push a)
559
#define PUSHA_L         CHOICE(pushal, pushal, _LTOG pusha)
560
#define PUSHA_W         CHOICE(pushaw, pushaw, _WTOG pusha)
561
#define PUSHF_L         CHOICE(pushfl, pushfl, _LTOG pushf)
562
#define PUSHF_W         CHOICE(pushfw, pushfw, _WTOG pushf)
563
#define RCL_L(a, b)     CHOICE(rcll ARG2(a,b), rcll ARG2(a,b), _LTOG rcl ARG2(b,a))
564
#define RCL_W(a, b)     CHOICE(rclw ARG2(a,b), rclw ARG2(a,b), _WTOG rcl ARG2(b,a))
565
#define RCL_B(a, b)     CHOICE(rclb ARG2(a,b), rclb ARG2(a,b), rclb ARG2(b,a))
566
#define RCR_L(a, b)     CHOICE(rcrl ARG2(a,b), rcrl ARG2(a,b), _LTOG rcr ARG2(b,a))
567
#define RCR_W(a, b)     CHOICE(rcrw ARG2(a,b), rcrw ARG2(a,b), _WTOG rcr ARG2(b,a))
568
#define RCR_B(a, b)     CHOICE(rcrb ARG2(a,b), rcrb ARG2(a,b), rcrb ARG2(b,a))
569
#define ROL_L(a, b)     CHOICE(roll ARG2(a,b), roll ARG2(a,b), _LTOG rol ARG2(b,a))
570
#define ROL_W(a, b)     CHOICE(rolw ARG2(a,b), rolw ARG2(a,b), _WTOG rol ARG2(b,a))
571
#define ROL_B(a, b)     CHOICE(rolb ARG2(a,b), rolb ARG2(a,b), rolb ARG2(b,a))
572
#define ROR_L(a, b)     CHOICE(rorl ARG2(a,b), rorl ARG2(a,b), _LTOG ror ARG2(b,a))
573
#define ROR_W(a, b)     CHOICE(rorw ARG2(a,b), rorw ARG2(a,b), _WTOG ror ARG2(b,a))
574
#define ROR_B(a, b)     CHOICE(rorb ARG2(a,b), rorb ARG2(a,b), rorb ARG2(b,a))
575
#define REP             CHOICE(rep ;, rep ;, repe)
576
#define REPE            CHOICE(repz ;, repe ;, repe)
577
#define REPNE           CHOICE(repnz ;, repne ;, repne)
578
#define REPNZ           REPNE
579
#define REPZ            REPE
580
#define RET             CHOICE(ret, ret, ret)
581
#define SAHF            CHOICE(sahf, sahf, sahf)
582
#define SAL_L(a, b)     CHOICE(sall ARG2(a,b), sall ARG2(a,b), _LTOG sal ARG2(b,a))
583
#define SAL_W(a, b)     CHOICE(salw ARG2(a,b), salw ARG2(a,b), _WTOG sal ARG2(b,a))
584
#define SAL_B(a, b)     CHOICE(salb ARG2(a,b), salb ARG2(a,b), salb ARG2(b,a))
585
#define SAR_L(a, b)     CHOICE(sarl ARG2(a,b), sarl ARG2(a,b), _LTOG sar ARG2(b,a))
586
#define SAR_W(a, b)     CHOICE(sarw ARG2(a,b), sarw ARG2(a,b), _WTOG sar ARG2(b,a))
587
#define SAR_B(a, b)     CHOICE(sarb ARG2(a,b), sarb ARG2(a,b), sarb ARG2(b,a))
588
#define SBB_L(a, b)     CHOICE(sbbl ARG2(a,b), sbbl ARG2(a,b), _LTOG sbb ARG2(b,a))
589
#define SBB_W(a, b)     CHOICE(sbbw ARG2(a,b), sbbw ARG2(a,b), _WTOG sbb ARG2(b,a))
590
#define SBB_B(a, b)     CHOICE(sbbb ARG2(a,b), sbbb ARG2(a,b), sbbb ARG2(b,a))
591
#define SCAS_L          CHOICE(scasl, scasl, _LTOG scas)
592
#define SCAS_W          CHOICE(scasw, scasw, _WTOG scas)
593
#define SCAS_B          CHOICE(scasb, scasb, scasb)
594
#define SETA(a)         CHOICE(seta a, seta a, seta a)
595
#define SETAE(a)        CHOICE(setae a, setae a, setae a)
596
#define SETB(a)         CHOICE(setb a, setb a, setb a)
597
#define SETBE(a)        CHOICE(setbe a, setbe a, setbe a)
598
#define SETC(a)         CHOICE(setc a, setb a, setb a)
599
#define SETE(a)         CHOICE(sete a, sete a, sete a)
600
#define SETG(a)         CHOICE(setg a, setg a, setg a)
601
#define SETGE(a)        CHOICE(setge a, setge a, setge a)
602
#define SETL(a)         CHOICE(setl a, setl a, setl a)
603
#define SETLE(a)        CHOICE(setle a, setle a, setle a)
604
#define SETNA(a)        CHOICE(setna a, setna a, setna a)
605
#define SETNAE(a)       CHOICE(setnae a, setnae a, setnae a)
606
#define SETNB(a)        CHOICE(setnb a, setnb a, setnb a)
607
#define SETNBE(a)       CHOICE(setnbe a, setnbe a, setnbe a)
608
#define SETNC(a)        CHOICE(setnc a, setnb a, setnb a)
609
#define SETNE(a)        CHOICE(setne a, setne a, setne a)
610
#define SETNG(a)        CHOICE(setng a, setng a, setng a)
611
#define SETNGE(a)       CHOICE(setnge a, setnge a, setnge a)
612
#define SETNL(a)        CHOICE(setnl a, setnl a, setnl a)
613
#define SETNLE(a)       CHOICE(setnle a, setnle a, setnle a)
614
#define SETNO(a)        CHOICE(setno a, setno a, setno a)
615
#define SETNP(a)        CHOICE(setnp a, setnp a, setnp a)
616
#define SETNS(a)        CHOICE(setns a, setns a, setna a)
617
#define SETNZ(a)        CHOICE(setnz a, setnz a, setnz a)
618
#define SETO(a)         CHOICE(seto a, seto a, seto a)
619
#define SETP(a)         CHOICE(setp a, setp a, setp a)
620
#define SETPE(a)        CHOICE(setpe a, setpe a, setpe a)
621
#define SETPO(a)        CHOICE(setpo a, setpo a, setpo a)
622
#define SETS(a)         CHOICE(sets a, sets a, seta a)
623
#define SETZ(a)         CHOICE(setz a, setz a, setz a)
624
#define SGDT(a)         CHOICE(sgdt a, sgdt a, sgdt a)
625
#define SIDT(a)         CHOICE(sidt a, sidt a, sidt a)
626
#define SHL_L(a, b)     CHOICE(shll ARG2(a,b), shll ARG2(a,b), _LTOG shl ARG2(b,a))
627
#define SHL_W(a, b)     CHOICE(shlw ARG2(a,b), shlw ARG2(a,b), _WTOG shl ARG2(b,a))
628
#define SHL_B(a, b)     CHOICE(shlb ARG2(a,b), shlb ARG2(a,b), shlb ARG2(b,a))
629
#define SHLD_L(a,b,c)   CHOICE(shldl ARG3(a,b,c), shldl ARG3(a,b,c), _LTOG shld ARG3(c,b,a))
630
#define SHLD2_L(a,b)    CHOICE(shldl ARG2(a,b), shldl ARG3(CL,a,b), _LTOG shld ARG3(b,a,CL))
631
#define SHLD_W(a,b,c)   CHOICE(shldw ARG3(a,b,c), shldw ARG3(a,b,c), _WTOG shld ARG3(c,b,a))
632
#define SHLD2_W(a,b)    CHOICE(shldw ARG2(a,b), shldw ARG3(CL,a,b), _WTOG shld ARG3(b,a,CL))
633
#define SHR_L(a, b)     CHOICE(shrl ARG2(a,b), shrl ARG2(a,b), _LTOG shr ARG2(b,a))
634
#define SHR_W(a, b)     CHOICE(shrw ARG2(a,b), shrw ARG2(a,b), _WTOG shr ARG2(b,a))
635
#define SHR_B(a, b)     CHOICE(shrb ARG2(a,b), shrb ARG2(a,b), shrb ARG2(b,a))
636
#define SHRD_L(a,b,c)   CHOICE(shrdl ARG3(a,b,c), shrdl ARG3(a,b,c), _LTOG shrd ARG3(c,b,a))
637
#define SHRD2_L(a,b)    CHOICE(shrdl ARG2(a,b), shrdl ARG3(CL,a,b), _LTOG shrd ARG3(b,a,CL))
638
#define SHRD_W(a,b,c)   CHOICE(shrdw ARG3(a,b,c), shrdw ARG3(a,b,c), _WTOG shrd ARG3(c,b,a))
639
#define SHRD2_W(a,b)    CHOICE(shrdw ARG2(a,b), shrdw ARG3(CL,a,b), _WTOG shrd ARG3(b,a,CL))
640
#define SLDT(a)         CHOICE(sldt a, sldt a, sldt a)
641
#define SMSW(a)         CHOICE(smsw a, smsw a, smsw a)
642
#define STC             CHOICE(stc, stc, stc)
643
#define STD             CHOICE(std, std, std)
644
#define STI             CHOICE(sti, sti, sti)
645
#define STOS_L          CHOICE(stosl, stosl, _LTOG stos)
646
#define STOS_W          CHOICE(stosw, stosw, _WTOG stos)
647
#define STOS_B          CHOICE(stosb, stosb, stosb)
648
#define STR(a)          CHOICE(str a, str a, str a)
649
#define SUB_L(a, b)     CHOICE(subl ARG2(a,b), subl ARG2(a,b), _LTOG sub ARG2(b,a))
650
#define SUB_W(a, b)     CHOICE(subw ARG2(a,b), subw ARG2(a,b), _WTOG sub ARG2(b,a))
651
#define SUB_B(a, b)     CHOICE(subb ARG2(a,b), subb ARG2(a,b), subb ARG2(b,a))
652
#define TEST_L(a, b)    CHOICE(testl ARG2(a,b), testl ARG2(a,b), _LTOG test ARG2(b,a))
653
#define TEST_W(a, b)    CHOICE(testw ARG2(a,b), testw ARG2(a,b), _WTOG test ARG2(b,a))
654
#define TEST_B(a, b)    CHOICE(testb ARG2(a,b), testb ARG2(a,b), testb ARG2(b,a))
655
#define VERR(a)         CHOICE(verr a, verr a, verr a)
656
#define VERW(a)         CHOICE(verw a, verw a, verw a)
657
#define WAIT            CHOICE(wait, wait, wait)
658
#define XCHG_L(a, b)    CHOICE(xchgl ARG2(a,b), xchgl ARG2(a,b), _LTOG xchg ARG2(b,a))
659
#define XCHG_W(a, b)    CHOICE(xchgw ARG2(a,b), xchgw ARG2(a,b), _WTOG xchg ARG2(b,a))
660
#define XCHG_B(a, b)    CHOICE(xchgb ARG2(a,b), xchgb ARG2(a,b), xchgb ARG2(b,a))
661
#define XLAT            CHOICE(xlat, xlat, xlat)
662
#define XOR_L(a, b)     CHOICE(xorl ARG2(a,b), xorl ARG2(a,b), _LTOG xor ARG2(b,a))
663
#define XOR_W(a, b)     CHOICE(xorw ARG2(a,b), xorw ARG2(a,b), _WTOG xor ARG2(b,a))
664
#define XOR_B(a, b)     CHOICE(xorb ARG2(a,b), xorb ARG2(a,b), xorb ARG2(b,a))
665
 
666
 
667
/* Floating Point Instructions */
668
#define F2XM1           CHOICE(f2xm1, f2xm1, f2xm1)
669
#define FABS            CHOICE(fabs, fabs, fabs)
670
#define FADD_D(a)       CHOICE(faddl a, faddl a, faddd a)
671
#define FADD_S(a)       CHOICE(fadds a, fadds a, fadds a)
672
#define FADD2(a, b)     CHOICE(fadd ARG2(a,b), fadd ARG2(a,b), fadd ARG2(b,a))
673
#define FADDP(a, b)     CHOICE(faddp ARG2(a,b), faddp ARG2(a,b), faddp ARG2(b,a))
674
#define FIADD_L(a)      CHOICE(fiaddl a, fiaddl a, fiaddl a)
675
#define FIADD_W(a)      CHOICE(fiadd a, fiadds a, fiadds a)
676
#define FBLD(a)         CHOICE(fbld a, fbld a, fbld a)
677
#define FBSTP(a)        CHOICE(fbstp a, fbstp a, fbstp a)
678
#define FCHS            CHOICE(fchs, fchs, fchs)
679
#define FCLEX           CHOICE(fclex, wait; fnclex, wait; fclex)
680
#define FNCLEX          CHOICE(fnclex, fnclex, fclex)
681
#define FCOM(a)         CHOICE(fcom a, fcom a, fcom a)
682
#define FCOM_D(a)       CHOICE(fcoml a, fcoml a, fcomd a)
683
#define FCOM_S(a)       CHOICE(fcoms a, fcoms a, fcoms a)
684
#define FCOMP(a)        CHOICE(fcomp a, fcomp a, fcomp a)
685
#define FCOMP_D(a)      CHOICE(fcompl a, fcompl a, fcompd a)
686
#define FCOMP_S(a)      CHOICE(fcomps a, fcomps a, fcomps a)
687
#define FCOMPP          CHOICE(fcompp, fcompp, fcompp)
688
#define FCOS            CHOICE(fcos, fcos, fcos)
689
#define FDECSTP         CHOICE(fdecstp, fdecstp, fdecstp)
690
#define FDIV_D(a)       CHOICE(fdivl a, fdivl a, fdivd a)
691
#define FDIV_S(a)       CHOICE(fdivs a, fdivs a, fdivs a)
692
#define FDIV2(a, b)     CHOICE(fdiv ARG2(a,b), fdiv ARG2(a,b), fdiv ARG2(b,a))
693
#define FDIVP(a, b)     CHOICE(fdivp ARG2(a,b), fdivp ARG2(a,b), fdivp ARG2(b,a))
694
#define FIDIV_L(a)      CHOICE(fidivl a, fidivl a, fidivl a)
695
#define FIDIV_W(a)      CHOICE(fidiv a, fidivs a, fidivs a)
696
#define FDIVR_D(a)      CHOICE(fdivrl a, fdivrl a, fdivrd a)
697
#define FDIVR_S(a)      CHOICE(fdivrs a, fdivrs a, fdivrs a)
698
#define FDIVR2(a, b)    CHOICE(fdivr ARG2(a,b), fdivr ARG2(a,b), fdivr ARG2(b,a))
699
#define FDIVRP(a, b)    CHOICE(fdivrp ARG2(a,b), fdivrp ARG2(a,b), fdivrp ARG2(b,a))
700
#define FIDIVR_L(a)     CHOICE(fidivrl a, fidivrl a, fidivrl a)
701
#define FIDIVR_W(a)     CHOICE(fidivr a, fidivrs a, fidivrs a)
702
#define FFREE(a)        CHOICE(ffree a, ffree a, ffree a)
703
#define FICOM_L(a)      CHOICE(ficoml a, ficoml a, ficoml a)
704
#define FICOM_W(a)      CHOICE(ficom a, ficoms a, ficoms a)
705
#define FICOMP_L(a)     CHOICE(ficompl a, ficompl a, ficompl a)
706
#define FICOMP_W(a)     CHOICE(ficomp a, ficomps a, ficomps a)
707
#define FILD_Q(a)       CHOICE(fildll a, fildq a, fildq a)
708
#define FILD_L(a)       CHOICE(fildl a, fildl a, fildl a)
709
#define FILD_W(a)       CHOICE(fild a, filds a, filds a)
710
#define FINCSTP         CHOICE(fincstp, fincstp, fincstp)
711
#define FINIT           CHOICE(finit, wait; fninit, wait; finit)
712
#define FNINIT          CHOICE(fninit, fninit, finit)
713
#define FIST_L(a)       CHOICE(fistl a, fistl a, fistl a)
714
#define FIST_W(a)       CHOICE(fist a, fists a, fists a)
715
#define FISTP_Q(a)      CHOICE(fistpll a, fistpq a, fistpq a)
716
#define FISTP_L(a)      CHOICE(fistpl a, fistpl a, fistpl a)
717
#define FISTP_W(a)      CHOICE(fistp a, fistps a, fistps a)
718
#define FLD_X(a)        CHOICE(fldt a, fldt a, fldx a) /* 80 bit data type! */
719
#define FLD_D(a)        CHOICE(fldl a, fldl a, fldd a)
720
#define FLD_S(a)        CHOICE(flds a, flds a, flds a)
721
#define FLD1            CHOICE(fld1, fld1, fld1)
722
#define FLDL2T          CHOICE(fldl2t, fldl2t, fldl2t)
723
#define FLDL2E          CHOICE(fldl2e, fldl2e, fldl2e)
724
#define FLDPI           CHOICE(fldpi, fldpi, fldpi)
725
#define FLDLG2          CHOICE(fldlg2, fldlg2, fldlg2)
726
#define FLDLN2          CHOICE(fldln2, fldln2, fldln2)
727
#define FLDZ            CHOICE(fldz, fldz, fldz)
728
#define FLDCW(a)        CHOICE(fldcw a, fldcw a, fldcw a)
729
#define FLDENV(a)       CHOICE(fldenv a, fldenv a, fldenv a)
730
#define FMUL_S(a)       CHOICE(fmuls a, fmuls a, fmuls a)
731
#define FMUL_D(a)       CHOICE(fmull a, fmull a, fmuld a)
732
#define FMUL2(a, b)     CHOICE(fmul ARG2(a,b), fmul ARG2(a,b), fmul ARG2(b,a))
733
#define FMULP(a, b)     CHOICE(fmulp ARG2(a,b), fmulp ARG2(a,b), fmulp ARG2(b,a))
734
#define FIMUL_L(a)      CHOICE(fimull a, fimull a, fimull a)
735
#define FIMUL_W(a)      CHOICE(fimul a, fimuls a, fimuls a)
736
#define FNOP            CHOICE(fnop, fnop, fnop)
737
#define FPATAN          CHOICE(fpatan, fpatan, fpatan)
738
#define FPREM           CHOICE(fprem, fprem, fprem)
739
#define FPREM1          CHOICE(fprem1, fprem1, fprem1)
740
#define FPTAN           CHOICE(fptan, fptan, fptan)
741
#define FRNDINT         CHOICE(frndint, frndint, frndint)
742
#define FRSTOR(a)       CHOICE(frstor a, frstor a, frstor a)
743
#define FSAVE(a)        CHOICE(fsave a, wait; fnsave a, wait; fsave a)
744
#define FNSAVE(a)       CHOICE(fnsave a, fnsave a, fsave a)
745
#define FSCALE          CHOICE(fscale, fscale, fscale)
746
#define FSIN            CHOICE(fsin, fsin, fsin)
747
#define FSINCOS         CHOICE(fsincos, fsincos, fsincos)
748
#define FSQRT           CHOICE(fsqrt, fsqrt, fsqrt)
749
#define FST_D(a)        CHOICE(fstl a, fstl a, fstd a)
750
#define FST_S(a)        CHOICE(fsts a, fsts a, fsts a)
751
#define FSTP_X(a)       CHOICE(fstpt a, fstpt a, fstpx a)
752
#define FSTP_D(a)       CHOICE(fstpl a, fstpl a, fstpd a)
753
#define FSTP_S(a)       CHOICE(fstps a, fstps a, fstps a)
754
#define FSTP(a)         CHOICE(fstp a, fstp a, fstp a)
755
#define FSTCW(a)        CHOICE(fstcw a, wait; fnstcw a, wait; fstcw a)
756
#define FNSTCW(a)       CHOICE(fnstcw a, fnstcw a, fstcw a)
757
#define FSTENV(a)       CHOICE(fstenv a, wait; fnstenv a, fstenv a)
758
#define FNSTENV(a)      CHOICE(fnstenv a, fnstenv a, fstenv a)
759
#define FSTSW(a)        CHOICE(fstsw a, wait; fnstsw a, wait; fstsw a)
760
#define FNSTSW(a)       CHOICE(fnstsw a, fnstsw a, fstsw a)
761
#define FSUB_S(a)       CHOICE(fsubs a, fsubs a, fsubs a)
762
#define FSUB_D(a)       CHOICE(fsubl a, fsubl a, fsubd a)
763
#define FSUB2(a, b)     CHOICE(fsub ARG2(a,b), fsub ARG2(a,b), fsub ARG2(b,a))
764
#define FSUBP(a, b)     CHOICE(fsubp ARG2(a,b), fsubp ARG2(a,b), fsubp ARG2(b,a))
765
#define FISUB_L(a)      CHOICE(fisubl a, fisubl a, fisubl a)
766
#define FISUB_W(a)      CHOICE(fisub a, fisubs a, fisubs a)
767
#define FSUBR_S(a)      CHOICE(fsubrs a, fsubrs a, fsubrs a)
768
#define FSUBR_D(a)      CHOICE(fsubrl a, fsubrl a, fsubrd a)
769
#define FSUBR2(a, b)    CHOICE(fsubr ARG2(a,b), fsubr ARG2(a,b), fsubr ARG2(b,a))
770
#define FSUBRP(a, b)    CHOICE(fsubrp ARG2(a,b), fsubrp ARG2(a,b), fsubrp ARG2(b,a))
771
#define FISUBR_L(a)     CHOICE(fisubrl a, fisubrl a, fisubrl a)
772
#define FISUBR_W(a)     CHOICE(fisubr a, fisubrs a, fisubrs a)
773
#define FTST            CHOICE(ftst, ftst, ftst)
774
#define FUCOM(a)        CHOICE(fucom a, fucom a, fucom a)
775
#define FUCOMP(a)       CHOICE(fucomp a, fucomp a, fucomp a)
776
#define FUCOMPP         CHOICE(fucompp, fucompp, fucompp)
777
#define FWAIT           CHOICE(wait, wait, wait)
778
#define FXAM            CHOICE(fxam, fxam, fxam)
779
#define FXCH(a)         CHOICE(fxch a, fxch a, fxch a)
780
#define FXTRACT         CHOICE(fxtract, fxtract, fxtract)
781
#define FYL2X           CHOICE(fyl2x, fyl2x, fyl2x)
782
#define FYL2XP1         CHOICE(fyl2xp1, fyl2xp1, fyl2xp1)
783
 
784
/* New instructions */
785
#define CPUID           CHOICE(D_BYTE ARG2(15, 162), cpuid, D_BYTE ARG2(15, 162))
786
#define RDTSC           CHOICE(D_BYTE ARG2(15, 49), rdtsc, D_BYTE ARG2(15, 49))
787
 
788
#else /* NASM_ASSEMBLER || MASM_ASSEMBLER is defined */
789
 
790
        /****************************************/
791
        /*                                      */
792
        /*      Intel style assemblers.         */
793
        /*      (NASM and MASM)                 */
794
        /*                                      */
795
        /****************************************/
796
 
797
#define P_EAX           EAX
798
#define L_EAX           EAX
799
#define W_AX            AX
800
#define B_AH            AH
801
#define B_AL            AL
802
 
803
#define P_EBX           EBX
804
#define L_EBX           EBX
805
#define W_BX            BX
806
#define B_BH            BH
807
#define B_BL            BL
808
 
809
#define P_ECX           ECX
810
#define L_ECX           ECX
811
#define W_CX            CX
812
#define B_CH            CH
813
#define B_CL            CL
814
 
815
#define P_EDX           EDX
816
#define L_EDX           EDX
817
#define W_DX            DX
818
#define B_DH            DH
819
#define B_DL            DL
820
 
821
#define P_EBP           EBP
822
#define L_EBP           EBP
823
#define W_BP            BP
824
 
825
#define P_ESI           ESI
826
#define L_ESI           ESI
827
#define W_SI            SI
828
 
829
#define P_EDI           EDI
830
#define L_EDI           EDI
831
#define W_DI            DI
832
 
833
#define P_ESP           ESP
834
#define L_ESP           ESP
835
#define W_SP            SP
836
 
837
#define W_CS            CS
838
#define W_SS            SS
839
#define W_DS            DS
840
#define W_ES            ES
841
#define W_FS            FS
842
#define W_GS            GS
843
 
844
#define X_ST            ST
845
#define D_ST            ST
846
#define L_ST            ST
847
 
848
#define P_MM0           mm0
849
#define P_MM1           mm1
850
#define P_MM2           mm2
851
#define P_MM3           mm3
852
#define P_MM4           mm4
853
#define P_MM5           mm5
854
#define P_MM6           mm6
855
#define P_MM7           mm7
856
 
857
#define P_XMM0          xmm0
858
#define P_XMM1          xmm1
859
#define P_XMM2          xmm2
860
#define P_XMM3          xmm3
861
#define P_XMM4          xmm4
862
#define P_XMM5          xmm5
863
#define P_XMM6          xmm6
864
#define P_XMM7          xmm7
865
 
866
#define CONCAT(x, y)    x ## y
867
 
868
#if defined(NASM_ASSEMBLER)
869
 
870
#define ST(n)           st ## n
871
#define ST0             st0
872
 
873
#define TBYTE_PTR       tword
874
#define QWORD_PTR       qword
875
#define DWORD_PTR       dword
876
#define WORD_PTR        word
877
#define BYTE_PTR        byte
878
 
879
#define OFFSET
880
 
881
#define GLOBL                   GLOBAL
882
#define ALIGNTEXT32             ALIGN 32
883
#define ALIGNTEXT16             ALIGN 16
884
#define ALIGNTEXT8              ALIGN 8
885
#define ALIGNTEXT4              ALIGN 4
886
#define ALIGNTEXT2              ALIGN 2
887
#define ALIGNTEXT32ifNOP        ALIGN 32
888
#define ALIGNTEXT16ifNOP        ALIGN 16
889
#define ALIGNTEXT8ifNOP         ALIGN 8
890
#define ALIGNTEXT4ifNOP         ALIGN 4
891
#define ALIGNDATA32             ALIGN 32
892
#define ALIGNDATA16             ALIGN 16
893
#define ALIGNDATA8              ALIGN 8
894
#define ALIGNDATA4              ALIGN 4
895
#define ALIGNDATA2              ALIGN 2
896
#define FILE(s)
897
#define STRING(s)       db s
898
#define D_LONG          dd
899
#define D_WORD          dw
900
#define D_BYTE          db
901
/* #define SPACE */
902
/* #define COMM */
903
#if defined(__WATCOMC__)
904
SECTION _TEXT public align=16 class=CODE use32 flat
905
SECTION _DATA public align=16 class=DATA use32 flat
906
#define SEG_TEXT        SECTION _TEXT
907
#define SEG_DATA        SECTION _DATA
908
#define SEG_BSS         SECTION .bss
909
#else
910
#define SEG_DATA        SECTION .data
911
#define SEG_TEXT        SECTION .text
912
#define SEG_BSS         SECTION .bss
913
#endif
914
 
915
#define D_SPACE(n)      db n REP 0
916
 
917
#define AS_BEGIN
918
 
919
/* Jcc's should be handled better than this... */
920
#define NEAR            near
921
 
922
#else /* MASM */
923
 
924
#define TBYTE_PTR       tbyte ptr
925
#define QWORD_PTR       qword ptr
926
#define DWORD_PTR       dword ptr
927
#define WORD_PTR        word ptr
928
#define BYTE_PTR        byte ptr
929
 
930
#define OFFSET          offset
931
 
932
#define GLOBL                   GLOBAL
933
#define ALIGNTEXT32             ALIGN 32
934
#define ALIGNTEXT16             ALIGN 16
935
#define ALIGNTEXT8              ALIGN 8
936
#define ALIGNTEXT4              ALIGN 4
937
#define ALIGNTEXT2              ALIGN 2
938
#define ALIGNTEXT32ifNOP        ALIGN 32
939
#define ALIGNTEXT16ifNOP        ALIGN 16
940
#define ALIGNTEXT8ifNOP         ALIGN 8
941
#define ALIGNTEXT4ifNOP         ALIGN 4
942
#define ALIGNDATA32             ALIGN 32
943
#define ALIGNDATA16             ALIGN 16
944
#define ALIGNDATA8              ALIGN 8
945
#define ALIGNDATA4              ALIGN 4
946
#define ALIGNDATA2              ALIGN 2
947
#define FILE(s)
948
#define STRING(s)       db s
949
#define D_LONG          dd
950
#define D_WORD          dw
951
#define D_BYTE          db
952
/* #define SPACE */
953
/* #define COMM */
954
#define SEG_DATA        .DATA
955
#define SEG_TEXT        .CODE
956
#define SEG_BSS         .DATA
957
 
958
#define D_SPACE(n)      db n REP 0
959
 
960
#define AS_BEGIN
961
 
962
#define NEAR
963
 
964
#endif
965
 
966
#if defined(Lynx) || (defined(SYSV) || defined(SVR4)) \
967
 || (defined(__linux__) || defined(__OS2ELF__)) && defined(__ELF__) \
968
 || defined(__FreeBSD__) && __FreeBSD__ >= 3
969
#define GLNAME(a)       a
970
#else
971
#define GLNAME(a)       CONCAT(_, a)
972
#endif
973
 
974
/*
975
 *      Addressing Modes
976
 */
977
 
978
/* Immediate Mode */
979
#define P_ADDR(a)               OFFSET a
980
#define X_ADDR(a)               OFFSET a
981
#define D_ADDR(a)               OFFSET a
982
#define L_ADDR(a)               OFFSET a
983
#define W_ADDR(a)               OFFSET a
984
#define B_ADDR(a)               OFFSET a
985
 
986
#define P_CONST(a)              a
987
#define X_CONST(a)              a
988
#define D_CONST(a)              a
989
#define L_CONST(a)              a
990
#define W_CONST(a)              a
991
#define B_CONST(a)              a
992
 
993
/* Indirect Mode */
994
#ifdef NASM_ASSEMBLER
995
#define P_CONTENT(a)            [a]
996
#define X_CONTENT(a)            TBYTE_PTR [a]
997
#define D_CONTENT(a)            QWORD_PTR [a]
998
#define L_CONTENT(a)            DWORD_PTR [a]
999
#define W_CONTENT(a)            WORD_PTR [a]
1000
#define B_CONTENT(a)            BYTE_PTR [a]
1001
#else
1002
#define P_CONTENT(a)            a
1003
#define X_CONTENT(a)            TBYTE_PTR a
1004
#define D_CONTENT(a)            QWORD_PTR a
1005
#define L_CONTENT(a)            DWORD_PTR a
1006
#define W_CONTENT(a)            WORD_PTR a
1007
#define B_CONTENT(a)            BYTE_PTR a
1008
#endif
1009
 
1010
/* Register a indirect */
1011
#define P_REGIND(a)             [a]
1012
#define X_REGIND(a)             TBYTE_PTR [a]
1013
#define D_REGIND(a)             QWORD_PTR [a]
1014
#define L_REGIND(a)             DWORD_PTR [a]
1015
#define W_REGIND(a)             WORD_PTR [a]
1016
#define B_REGIND(a)             BYTE_PTR [a]
1017
 
1018
/* Register b indirect plus displacement a */
1019
#define P_REGOFF(a, b)          [b + a]
1020
#define X_REGOFF(a, b)          TBYTE_PTR [b + a]
1021
#define D_REGOFF(a, b)          QWORD_PTR [b + a]
1022
#define L_REGOFF(a, b)          DWORD_PTR [b + a]
1023
#define W_REGOFF(a, b)          WORD_PTR [b + a]
1024
#define B_REGOFF(a, b)          BYTE_PTR [b + a]
1025
 
1026
/* Reg indirect Base + Index + Displacement  - this is mainly for 16-bit mode
1027
 * which has no scaling
1028
 */
1029
#define P_REGBID(b, i, d)       [b + i + d]
1030
#define X_REGBID(b, i, d)       TBYTE_PTR [b + i + d]
1031
#define D_REGBID(b, i, d)       QWORD_PTR [b + i + d]
1032
#define L_REGBID(b, i, d)       DWORD_PTR [b + i + d]
1033
#define W_REGBID(b, i, d)       WORD_PTR [b + i + d]
1034
#define B_REGBID(b, i, d)       BYTE_PTR [b + i + d]
1035
 
1036
/* Reg indirect Base + (Index * Scale) */
1037
#define P_REGBIS(b, i, s)       [b + i * s]
1038
#define X_REGBIS(b, i, s)       TBYTE_PTR [b + i * s]
1039
#define D_REGBIS(b, i, s)       QWORD_PTR [b + i * s]
1040
#define L_REGBIS(b, i, s)       DWORD_PTR [b + i * s]
1041
#define W_REGBIS(b, i, s)       WORD_PTR [b + i * s]
1042
#define B_REGBIS(b, i, s)       BYTE_PTR [b + i * s]
1043
 
1044
/* Reg indirect Base + (Index * Scale) + Displacement */
1045
#define P_REGBISD(b, i, s, d)   [b + i * s + d]
1046
#define X_REGBISD(b, i, s, d)   TBYTE_PTR [b + i * s + d]
1047
#define D_REGBISD(b, i, s, d)   QWORD_PTR [b + i * s + d]
1048
#define L_REGBISD(b, i, s, d)   DWORD_PTR [b + i * s + d]
1049
#define W_REGBISD(b, i, s, d)   WORD_PTR [b + i * s + d]
1050
#define B_REGBISD(b, i, s, d)   BYTE_PTR [b + i * s + d]
1051
 
1052
/* Displaced Scaled Index: */
1053
#define P_REGDIS(d, i, s)       [i * s + d]
1054
#define X_REGDIS(d, i, s)       TBYTE_PTR [i * s + d]
1055
#define D_REGDIS(d, i, s)       QWORD_PTR [i * s + d]
1056
#define L_REGDIS(d, i, s)       DWORD_PTR [i * s + d]
1057
#define W_REGDIS(d, i, s)       WORD_PTR [i * s + d]
1058
#define B_REGDIS(d, i, s)       BYTE_PTR [i * s + d]
1059
 
1060
/* Indexed Base: */
1061
#define P_REGBI(b, i)           [b + i]
1062
#define X_REGBI(b, i)           TBYTE_PTR [b + i]
1063
#define D_REGBI(b, i)           QWORD_PTR [b + i]
1064
#define L_REGBI(b, i)           DWORD_PTR [b + i]
1065
#define W_REGBI(b, i)           WORD_PTR [b + i]
1066
#define B_REGBI(b, i)           BYTE_PTR [b + i]
1067
 
1068
/* Displaced Base: */
1069
#define P_REGDB(d, b)           [b + d]
1070
#define X_REGDB(d, b)           TBYTE_PTR [b + d]
1071
#define D_REGDB(d, b)           QWORD_PTR [b + d]
1072
#define L_REGDB(d, b)           DWORD_PTR [b + d]
1073
#define W_REGDB(d, b)           WORD_PTR [b + d]
1074
#define B_REGDB(d, b)           BYTE_PTR [b + d]
1075
 
1076
/* Variable indirect: */
1077
#define VARINDIRECT(var)        var
1078
 
1079
/* Use register contents as jump/call target: */
1080
#define CODEPTR(reg)            P_(reg)
1081
 
1082
/*
1083
 * Redefine assembler commands
1084
 */
1085
 
1086
#define P_(a)                   P_ ## a
1087
#define X_(a)                   X_ ## a
1088
#define D_(a)                   D_ ## a
1089
#define S_(a)                   L_ ## a
1090
#define L_(a)                   L_ ## a
1091
#define W_(a)                   W_ ## a
1092
#define B_(a)                   B_ ## a
1093
 
1094
#define AAA                     aaa
1095
#define AAD                     aad
1096
#define AAM                     aam
1097
#define AAS                     aas
1098
#define ADC_L(a, b)             adc L_(b), L_(a)
1099
#define ADC_W(a, b)             adc W_(b), W_(a)
1100
#define ADC_B(a, b)             adc B_(b), B_(a)
1101
#define ADD_L(a, b)             add L_(b), L_(a)
1102
#define ADD_W(a, b)             add W_(b), W_(a)
1103
#define ADD_B(a, b)             add B_(b), B_(a)
1104
#define AND_L(a, b)             and L_(b), L_(a)
1105
#define AND_W(a, b)             and W_(b), W_(a)
1106
#define AND_B(a, b)             and B_(b), B_(a)
1107
#define ARPL(a,b)               arpl W_(b), a
1108
#define BOUND_L(a, b)           bound L_(b), L_(a)
1109
#define BOUND_W(a, b)           bound W_(b), W_(a)
1110
#define BSF_L(a, b)             bsf L_(b), L_(a)
1111
#define BSF_W(a, b)             bsf W_(b), W_(a)
1112
#define BSR_L(a, b)             bsr L_(b), L_(a)
1113
#define BSR_W(a, b)             bsr W_(b), W_(a)
1114
#define BT_L(a, b)              bt L_(b), L_(a)
1115
#define BT_W(a, b)              bt W_(b), W_(a)
1116
#define BTC_L(a, b)             btc L_(b), L_(a)
1117
#define BTC_W(a, b)             btc W_(b), W_(a)
1118
#define BTR_L(a, b)             btr L_(b), L_(a)
1119
#define BTR_W(a, b)             btr W_(b), W_(a)
1120
#define BTS_L(a, b)             bts L_(b), L_(a)
1121
#define BTS_W(a, b)             bts W_(b), W_(a)
1122
#define CALL(a)                 call a
1123
#define CALLF(s,a)              call far s:a
1124
#define CBW                     cbw
1125
#define CWDE                    cwde
1126
#define CLC                     clc
1127
#define CLD                     cld
1128
#define CLI                     cli
1129
#define CLTS                    clts
1130
#define CMC                     cmc
1131
#define CMP_L(a, b)             cmp L_(b), L_(a)
1132
#define CMP_W(a, b)             cmp W_(b), W_(a)
1133
#define CMP_B(a, b)             cmp B_(b), B_(a)
1134
#define CMPS_L                  cmpsd
1135
#define CMPS_W                  cmpsw
1136
#define CMPS_B                  cmpsb
1137
#define CPUID                   cpuid
1138
#define CWD                     cwd
1139
#define CDQ                     cdq
1140
#define DAA                     daa
1141
#define DAS                     das
1142
#define DEC_L(a)                dec L_(a)
1143
#define DEC_W(a)                dec W_(a)
1144
#define DEC_B(a)                dec B_(a)
1145
#define DIV_L(a)                div L_(a)
1146
#define DIV_W(a)                div W_(a)
1147
#define DIV_B(a)                div B_(a)
1148
#define ENTER(a,b)              enter b, a
1149
#define HLT                     hlt
1150
#define IDIV_L(a)               idiv L_(a)
1151
#define IDIV_W(a)               idiv W_(a)
1152
#define IDIV_B(a)               idiv B_(a)
1153
#define IMUL_L(a, b)            imul L_(b), L_(a)
1154
#define IMUL_W(a, b)            imul W_(b), W_(a)
1155
#define IMUL_B(a)               imul B_(a)
1156
#define IN_L                    in EAX, DX
1157
#define IN_W                    in AX, DX
1158
#define IN_B                    in AL, DX
1159
#define IN1_L(a)                in1 L_(a)
1160
#define IN1_W(a)                in1 W_(a)
1161
#define IN1_B(a)                in1 B_(a)
1162
#define INC_L(a)                inc L_(a)
1163
#define INC_W(a)                inc W_(a)
1164
#define INC_B(a)                inc B_(a)
1165
#define INS_L                   ins
1166
#define INS_W                   ins
1167
#define INS_B                   ins
1168
#define INT(a)                  int B_(a)
1169
#define INT3                    int3
1170
#define INTO                    into
1171
#define IRET                    iret
1172
#define IRETD                   iretd
1173
#define JA(a)                   ja NEAR a
1174
#define JAE(a)                  jae NEAR a
1175
#define JB(a)                   jb NEAR a
1176
#define JBE(a)                  jbe NEAR a
1177
#define JC(a)                   jc NEAR a
1178
#define JE(a)                   je NEAR a
1179
#define JG(a)                   jg NEAR a
1180
#define JGE(a)                  jge NEAR a
1181
#define JL(a)                   jl NEAR a
1182
#define JLE(a)                  jle NEAR a
1183
#define JNA(a)                  jna NEAR a
1184
#define JNAE(a)                 jnae NEAR a
1185
#define JNB(a)                  jnb NEAR a
1186
#define JNBE(a)                 jnbe NEAR a
1187
#define JNC(a)                  jnc NEAR a
1188
#define JNE(a)                  jne NEAR a
1189
#define JNG(a)                  jng NEAR a
1190
#define JNGE(a)                 jnge NEAR a
1191
#define JNL(a)                  jnl NEAR a
1192
#define JNLE(a)                 jnle NEAR a
1193
#define JNO(a)                  jno NEAR a
1194
#define JNP(a)                  jnp NEAR a
1195
#define JNS(a)                  jns NEAR a
1196
#define JNZ(a)                  jnz NEAR a
1197
#define JO(a)                   jo NEAR a
1198
#define JP(a)                   jp NEAR a
1199
#define JPE(a)                  jpe NEAR a
1200
#define JPO(a)                  jpo NEAR a
1201
#define JS(a)                   js NEAR a
1202
#define JZ(a)                   jz NEAR a
1203
#define JMP(a)                  jmp a
1204
#define JMPF(s,a)               jmp far s:a
1205
#define LAHF                    lahf
1206
#define LAR(a, b)               lar b, a
1207
#define LEA_L(a, b)             lea P_(b), P_(a)
1208
#define LEA_W(a, b)             lea P_(b), P_(a)
1209
#define LEAVE                   leave
1210
#define LGDT(a)                 lgdt a
1211
#define LIDT(a)                 lidt a
1212
#define LDS(a, b)               lds b, a
1213
#define LES(a, b)               les b, a
1214
#define LFS(a, b)               lfs b, a
1215
#define LGS(a, b)               lgs b, a
1216
#define LSS(a, b)               lss b, a
1217
#define LLDT(a)                 lldt a
1218
#define LMSW(a)                 lmsw a
1219
#define LOCK                    lock
1220
#define LODS_L                  lodsd
1221
#define LODS_W                  lodsw
1222
#define LODS_B                  lodsb
1223
#define LOOP(a)                 loop a
1224
#define LOOPE(a)                loope a
1225
#define LOOPZ(a)                loopz a
1226
#define LOOPNE(a)               loopne a
1227
#define LOOPNZ(a)               loopnz a
1228
#define LSL(a, b)               lsl b, a
1229
#define LTR(a)                  ltr a
1230
#define MOV_SR(a, b)            mov S_(b), S_(a)
1231
#define MOV_L(a, b)             mov L_(b), L_(a)
1232
#define MOV_W(a, b)             mov W_(b), W_(a)
1233
#define MOV_B(a, b)             mov B_(b), B_(a)
1234
#define MOVS_L                  movsd
1235
#define MOVS_W                  movsw
1236
#define MOVS_B                  movsb
1237
#define MOVSX_BL(a, b)          movsx B_(b), B_(a)
1238
#define MOVSX_BW(a, b)          movsx B_(b), B_(a)
1239
#define MOVSX_WL(a, b)          movsx W_(b), W_(a)
1240
#define MOVZX_BL(a, b)          movzx B_(b), B_(a)
1241
#define MOVZX_BW(a, b)          movzx B_(b), B_(a)
1242
#define MOVZX_WL(a, b)          movzx W_(b), W_(a)
1243
#define MUL_L(a)                mul L_(a)
1244
#define MUL_W(a)                mul W_(a)
1245
#define MUL_B(a)                mul B_(a)
1246
#define NEG_L(a)                neg L_(a)
1247
#define NEG_W(a)                neg W_(a)
1248
#define NEG_B(a)                neg B_(a)
1249
#define NOP                     nop
1250
#define NOT_L(a)                not L_(a)
1251
#define NOT_W(a)                not W_(a)
1252
#define NOT_B(a)                not B_(a)
1253
#define OR_L(a,b)               or L_(b), L_(a)
1254
#define OR_W(a,b)               or W_(b), W_(a)
1255
#define OR_B(a,b)               or B_(b), B_(a)
1256
#define OUT_L                   out DX, EAX
1257
#define OUT_W                   out DX, AX
1258
#define OUT_B                   out DX, AL
1259
#define OUT1_L(a)               out1 L_(a)
1260
#define OUT1_W(a)               out1 W_(a)
1261
#define OUT1_B(a)               out1 B_(a)
1262
#define OUTS_L                  outsd
1263
#define OUTS_W                  outsw
1264
#define OUTS_B                  outsb
1265
#define POP_SR(a)               pop S_(a)
1266
#define POP_L(a)                pop L_(a)
1267
#define POP_W(a)                pop W_(a)
1268
#define POPA_L                  popad
1269
#define POPA_W                  popa
1270
#define POPF_L                  popfd
1271
#define POPF_W                  popf
1272
#define PUSH_SR(a)              push S_(a)
1273
#define PUSH_L(a)               push L_(a)
1274
#define PUSH_W(a)               push W_(a)
1275
#define PUSH_B(a)               push B_(a)
1276
#define PUSHA_L                 pushad
1277
#define PUSHA_W                 pusha
1278
#define PUSHF_L                 pushfd
1279
#define PUSHF_W                 pushf
1280
#define RCL_L(a, b)             rcl L_(b), L_(a)
1281
#define RCL_W(a, b)             rcl W_(b), W_(a)
1282
#define RCL_B(a, b)             rcl B_(b), B_(a)
1283
#define RCR_L(a, b)             rcr L_(b), L_(a)
1284
#define RCR_W(a, b)             rcr W_(b), W_(a)
1285
#define RCR_B(a, b)             rcr B_(b), B_(a)
1286
#define RDTSC                   rdtsc
1287
#define ROL_L(a, b)             rol L_(b), L_(a)
1288
#define ROL_W(a, b)             rol W_(b), W_(a)
1289
#define ROL_B(a, b)             rol B_(b), B_(a)
1290
#define ROR_L(a, b)             ror L_(b), L_(a)
1291
#define ROR_W(a, b)             ror W_(b), W_(a)
1292
#define ROR_B(a, b)             ror B_(b), B_(a)
1293
#define REP                     rep
1294
#define REPE                    repe
1295
#define REPNE                   repne
1296
#define REPNZ                   REPNE
1297
#define REPZ                    REPE
1298
#define RET                     ret
1299
#define SAHF                    sahf
1300
#define SAL_L(a, b)             sal L_(b), L_(a)
1301
#define SAL_W(a, b)             sal W_(b), W_(a)
1302
#define SAL_B(a, b)             sal B_(b), B_(a)
1303
#define SAR_L(a, b)             sar L_(b), L_(a)
1304
#define SAR_W(a, b)             sar W_(b), W_(a)
1305
#define SAR_B(a, b)             sar B_(b), B_(a)
1306
#define SBB_L(a, b)             sbb L_(b), L_(a)
1307
#define SBB_W(a, b)             sbb W_(b), W_(a)
1308
#define SBB_B(a, b)             sbb B_(b), B_(a)
1309
#define SCAS_L                  scas
1310
#define SCAS_W                  scas
1311
#define SCAS_B                  scas
1312
#define SETA(a)                 seta a
1313
#define SETAE(a)                setae a
1314
#define SETB(a)                 setb a
1315
#define SETBE(a)                setbe a
1316
#define SETC(a)                 setc a
1317
#define SETE(a)                 sete a
1318
#define SETG(a)                 setg a
1319
#define SETGE(a)                setge a
1320
#define SETL(a)                 setl a
1321
#define SETLE(a)                setle a
1322
#define SETNA(a)                setna a
1323
#define SETNAE(a)               setnae a
1324
#define SETNB(a)                setnb a
1325
#define SETNBE(a)               setnbe a
1326
#define SETNC(a)                setnc a
1327
#define SETNE(a)                setne a
1328
#define SETNG(a)                setng a
1329
#define SETNGE(a)               setnge a
1330
#define SETNL(a)                setnl a
1331
#define SETNLE(a)               setnle a
1332
#define SETNO(a)                setno a
1333
#define SETNP(a)                setnp a
1334
#define SETNS(a)                setns a
1335
#define SETNZ(a)                setnz a
1336
#define SETO(a)                 seto a
1337
#define SETP(a)                 setp a
1338
#define SETPE(a)                setpe a
1339
#define SETPO(a)                setpo a
1340
#define SETS(a)                 sets a
1341
#define SETZ(a)                 setz a
1342
#define SGDT(a)                 sgdt a
1343
#define SIDT(a)                 sidt a
1344
#define SHL_L(a, b)             shl L_(b), L_(a)
1345
#define SHL_W(a, b)             shl W_(b), W_(a)
1346
#define SHL_B(a, b)             shl B_(b), B_(a)
1347
#define SHLD_L(a,b,c)           shld
1348
#define SHLD2_L(a,b)            shld L_(b), L_(a)
1349
#define SHLD_W(a,b,c)           shld
1350
#define SHLD2_W(a,b)            shld W_(b), W_(a)
1351
#define SHR_L(a, b)             shr L_(b), L_(a)
1352
#define SHR_W(a, b)             shr W_(b), W_(a)
1353
#define SHR_B(a, b)             shr B_(b), B_(a)
1354
#define SHRD_L(a,b,c)           shrd
1355
#define SHRD2_L(a,b)            shrd L_(b), L_(a)
1356
#define SHRD_W(a,b,c)           shrd
1357
#define SHRD2_W(a,b)            shrd W_(b), W_(a)
1358
#define SLDT(a)                 sldt a
1359
#define SMSW(a)                 smsw a
1360
#define STC                     stc
1361
#define STD                     std
1362
#define STI                     sti
1363
#define STOS_L                  stos
1364
#define STOS_W                  stos
1365
#define STOS_B                  stos
1366
#define STR(a)                  str a
1367
#define SUB_L(a, b)             sub L_(b), L_(a)
1368
#define SUB_W(a, b)             sub W_(b), W_(a)
1369
#define SUB_B(a, b)             sub B_(b), B_(a)
1370
#define TEST_L(a, b)            test L_(b), L_(a)
1371
#define TEST_W(a, b)            test W_(b), W_(a)
1372
#define TEST_B(a, b)            test B_(b), B_(a)
1373
#define VERR(a)                 verr a
1374
#define VERW(a)                 verw a
1375
#define WAIT                    wait
1376
#define XCHG_L(a, b)            xchg L_(b), L_(a)
1377
#define XCHG_W(a, b)            xchg W_(b), W_(a)
1378
#define XCHG_B(a, b)            xchg B_(b), B_(a)
1379
#define XLAT                    xlat
1380
#define XOR_L(a, b)             xor L_(b), L_(a)
1381
#define XOR_W(a, b)             xor W_(b), W_(a)
1382
#define XOR_B(a, b)             xor B_(b), B_(a)
1383
 
1384
 
1385
/* Floating Point Instructions */
1386
#define F2XM1                   f2xm1
1387
#define FABS                    fabs
1388
#define FADD_D(a)               fadd D_(a)
1389
#define FADD_S(a)               fadd S_(a)
1390
#define FADD2(a, b)             fadd b, a
1391
#define FADDP(a, b)             faddp b, a
1392
#define FIADD_L(a)              fiadd L_(a)
1393
#define FIADD_W(a)              fiadd W_(a)
1394
#define FBLD(a)                 fbld a
1395
#define FBSTP(a)                fbstp a
1396
#define FCHS                    fchs
1397
#define FCLEX                   fclex
1398
#define FNCLEX                  fnclex
1399
#define FCOM(a)                 fcom a
1400
#define FCOM_D(a)               fcom D_(a)
1401
#define FCOM_S(a)               fcom S_(a)
1402
#define FCOMP(a)                fcomp a
1403
#define FCOMP_D(a)              fcomp D_(a)
1404
#define FCOMP_S(a)              fcomp S_(a)
1405
#define FCOMPP                  fcompp
1406
#define FCOS                    fcos
1407
#define FDECSTP                 fdecstp
1408
#define FDIV_D(a)               fdiv D_(a)
1409
#define FDIV_S(a)               fdiv S_(a)
1410
#define FDIV2(a, b)             fdiv b, a
1411
#define FDIVP(a, b)             fdivp b, a
1412
#define FIDIV_L(a)              fidiv L_(a)
1413
#define FIDIV_W(a)              fidiv W_(a)
1414
#define FDIVR_D(a)              fdivr D_(a)
1415
#define FDIVR_S(a)              fdivr S_(a)
1416
#define FDIVR2(a, b)            fdivr b, a
1417
#define FDIVRP(a, b)            fdivrp b, a
1418
#define FIDIVR_L(a)             fidivr L_(a)
1419
#define FIDIVR_W(a)             fidivr W_(a)
1420
#define FFREE(a)                ffree a
1421
#define FICOM_L(a)              ficom L_(a)
1422
#define FICOM_W(a)              ficom W_(a)
1423
#define FICOMP_L(a)             ficomp L_(a)
1424
#define FICOMP_W(a)             ficomp W_(a)
1425
#define FILD_Q(a)               fild D_(a)
1426
#define FILD_L(a)               fild L_(a)
1427
#define FILD_W(a)               fild W_(a)
1428
#define FINCSTP                 fincstp
1429
#define FINIT                   finit
1430
#define FNINIT                  fninit
1431
#define FIST_L(a)               fist L_(a)
1432
#define FIST_W(a)               fist W_(a)
1433
#define FISTP_Q(a)              fistp D_(a)
1434
#define FISTP_L(a)              fistp L_(a)
1435
#define FISTP_W(a)              fistp W_(a)
1436
#define FLD_X(a)                fld X_(a)
1437
#define FLD_D(a)                fld D_(a)
1438
#define FLD_S(a)                fld S_(a)
1439
#define FLD1                    fld1
1440
#define FLDL2T                  fldl2t
1441
#define FLDL2E                  fldl2e
1442
#define FLDPI                   fldpi
1443
#define FLDLG2                  fldlg2
1444
#define FLDLN2                  fldln2
1445
#define FLDZ                    fldz
1446
#define FLDCW(a)                fldcw a
1447
#define FLDENV(a)               fldenv a
1448
#define FMUL_S(a)               fmul S_(a)
1449
#define FMUL_D(a)               fmul D_(a)
1450
#define FMUL2(a, b)             fmul b, a
1451
#define FMULP(a, b)             fmulp b, a
1452
#define FIMUL_L(a)              fimul L_(a)
1453
#define FIMUL_W(a)              fimul W_(a)
1454
#define FNOP                    fnop
1455
#define FPATAN                  fpatan
1456
#define FPREM                   fprem
1457
#define FPREM1                  fprem1
1458
#define FPTAN                   fptan
1459
#define FRNDINT                 frndint
1460
#define FRSTOR(a)               frstor a
1461
#define FSAVE(a)                fsave a
1462
#define FNSAVE(a)               fnsave a
1463
#define FSCALE                  fscale
1464
#define FSIN                    fsin
1465
#define FSINCOS                 fsincos
1466
#define FSQRT                   fsqrt
1467
#define FST_D(a)                fst D_(a)
1468
#define FST_S(a)                fst S_(a)
1469
#define FSTP_X(a)               fstp X_(a)
1470
#define FSTP_D(a)               fstp D_(a)
1471
#define FSTP_S(a)               fstp S_(a)
1472
#define FSTP(a)                 fstp a
1473
#define FSTCW(a)                fstcw a
1474
#define FNSTCW(a)               fnstcw a
1475
#define FSTENV(a)               fstenv a
1476
#define FNSTENV(a)              fnstenv a
1477
#define FSTSW(a)                fstsw a
1478
#define FNSTSW(a)               fnstsw a
1479
#define FSUB_S(a)               fsub S_(a)
1480
#define FSUB_D(a)               fsub D_(a)
1481
#define FSUB2(a, b)             fsub b, a
1482
#define FSUBP(a, b)             fsubp b, a
1483
#define FISUB_L(a)              fisub L_(a)
1484
#define FISUB_W(a)              fisub W_(a)
1485
#define FSUBR_S(a)              fsubr S_(a)
1486
#define FSUBR_D(a)              fsubr D_(a)
1487
#define FSUBR2(a, b)            fsubr b, a
1488
#define FSUBRP(a, b)            fsubrp b, a
1489
#define FISUBR_L(a)             fisubr L_(a)
1490
#define FISUBR_W(a)             fisubr W_(a)
1491
#define FTST                    ftst
1492
#define FUCOM(a)                fucom a
1493
#define FUCOMP(a)               fucomp a
1494
#define FUCOMPP                 fucompp
1495
#define FWAIT                   fwait
1496
#define FXAM                    fxam
1497
#define FXCH(a)                 fxch a
1498
#define FXTRACT                 fxtract
1499
#define FYL2X                   fyl2x
1500
#define FYL2XP1                 fyl2xp1
1501
 
1502
#endif /* NASM_ASSEMBLER, MASM_ASSEMBLER */
1503
 
1504
        /****************************************/
1505
        /*                                      */
1506
        /*      Extensions to x86 insn set -    */
1507
        /*      MMX, 3DNow!                     */
1508
        /*                                      */
1509
        /****************************************/
1510
 
1511
#if defined(NASM_ASSEMBLER) || defined(MASM_ASSEMBLER)
1512
#define P_ARG1(a)               P_ ## a
1513
#define P_ARG2(a, b)            P_ ## b, P_ ## a
1514
#define P_ARG3(a, b, c)         P_ ## c, P_ ## b, P_ ## a
1515
#else
1516
#define P_ARG1(a)               a
1517
#define P_ARG2(a, b)            a, b
1518
#define P_ARG3(a, b, c)         a, b, c
1519
#endif
1520
 
1521
/* MMX */
1522
#define MOVD(a, b)              movd P_ARG2(a, b)
1523
#define MOVQ(a, b)              movq P_ARG2(a, b)
1524
 
1525
#define PADDB(a, b)             paddb P_ARG2(a, b)
1526
#define PADDW(a, b)             paddw P_ARG2(a, b)
1527
#define PADDD(a, b)             paddd P_ARG2(a, b)
1528
 
1529
#define PADDSB(a, b)            paddsb P_ARG2(a, b)
1530
#define PADDSW(a, b)            paddsw P_ARG2(a, b)
1531
 
1532
#define PADDUSB(a, b)           paddusb P_ARG2(a, b)
1533
#define PADDUSW(a, b)           paddusw P_ARG2(a, b)
1534
 
1535
#define PSUBB(a, b)             psubb P_ARG2(a, b)
1536
#define PSUBW(a, b)             psubw P_ARG2(a, b)
1537
#define PSUBD(a, b)             psubd P_ARG2(a, b)
1538
 
1539
#define PSUBSB(a, b)            psubsb P_ARG2(a, b)
1540
#define PSUBSW(a, b)            psubsw P_ARG2(a, b)
1541
 
1542
#define PSUBUSB(a, b)           psubusb P_ARG2(a, b)
1543
#define PSUBUSW(a, b)           psubusw P_ARG2(a, b)
1544
 
1545
#define PCMPEQB(a, b)           pcmpeqb P_ARG2(a, b)
1546
#define PCMPEQW(a, b)           pcmpeqw P_ARG2(a, b)
1547
#define PCMPEQD(a, b)           pcmpeqd P_ARG2(a, b)
1548
 
1549
#define PCMPGTB(a, b)           pcmpgtb P_ARG2(a, b)
1550
#define PCMPGTW(a, b)           pcmpgtw P_ARG2(a, b)
1551
#define PCMPGTD(a, b)           pcmpgtd P_ARG2(a, b)
1552
 
1553
#define PMULHW(a, b)            pmulhw P_ARG2(a, b)
1554
#define PMULLW(a, b)            pmullw P_ARG2(a, b)
1555
 
1556
#define PMADDWD(a, b)           pmaddwd P_ARG2(a, b)
1557
 
1558
#define PAND(a, b)              pand P_ARG2(a, b)
1559
 
1560
#define PANDN(a, b)             pandn P_ARG2(a, b)
1561
 
1562
#define POR(a, b)               por P_ARG2(a, b)
1563
 
1564
#define PXOR(a, b)              pxor P_ARG2(a, b)
1565
 
1566
#define PSRAW(a, b)             psraw P_ARG2(a, b)
1567
#define PSRAD(a, b)             psrad P_ARG2(a, b)
1568
 
1569
#define PSRLW(a, b)             psrlw P_ARG2(a, b)
1570
#define PSRLD(a, b)             psrld P_ARG2(a, b)
1571
#define PSRLQ(a, b)             psrlq P_ARG2(a, b)
1572
 
1573
#define PSLLW(a, b)             psllw P_ARG2(a, b)
1574
#define PSLLD(a, b)             pslld P_ARG2(a, b)
1575
#define PSLLQ(a, b)             psllq P_ARG2(a, b)
1576
 
1577
#define PACKSSWB(a, b)          packsswb P_ARG2(a, b)
1578
#define PACKSSDW(a, b)          packssdw P_ARG2(a, b)
1579
#define PACKUSWB(a, b)          packuswb P_ARG2(a, b)
1580
 
1581
#define PUNPCKHBW(a, b)         punpckhbw P_ARG2(a, b)
1582
#define PUNPCKHWD(a, b)         punpckhwd P_ARG2(a, b)
1583
#define PUNPCKHDQ(a, b)         punpckhdq P_ARG2(a, b)
1584
#define PUNPCKLBW(a, b)         punpcklbw P_ARG2(a, b)
1585
#define PUNPCKLWD(a, b)         punpcklwd P_ARG2(a, b)
1586
#define PUNPCKLDQ(a, b)         punpckldq P_ARG2(a, b)
1587
 
1588
#define EMMS                    emms
1589
 
1590
/* AMD 3DNow! */
1591
#define PAVGUSB(a, b)           pavgusb P_ARG2(a, b)
1592
#define PFADD(a, b)             pfadd P_ARG2(a, b)
1593
#define PFSUB(a, b)             pfsub P_ARG2(a, b)
1594
#define PFSUBR(a, b)            pfsubr P_ARG2(a, b)
1595
#define PFACC(a, b)             pfacc P_ARG2(a, b)
1596
#define PFCMPGE(a, b)           pfcmpge P_ARG2(a, b)
1597
#define PFCMPGT(a, b)           pfcmpgt P_ARG2(a, b)
1598
#define PFCMPEQ(a, b)           pfcmpeq P_ARG2(a, b)
1599
#define PFMIN(a, b)             pfmin P_ARG2(a, b)
1600
#define PFMAX(a, b)             pfmax P_ARG2(a, b)
1601
#define PI2FD(a, b)             pi2fd P_ARG2(a, b)
1602
#define PF2ID(a, b)             pf2id P_ARG2(a, b)
1603
#define PFRCP(a, b)             pfrcp P_ARG2(a, b)
1604
#define PFRSQRT(a, b)           pfrsqrt P_ARG2(a, b)
1605
#define PFMUL(a, b)             pfmul P_ARG2(a, b)
1606
#define PFRCPIT1(a, b)          pfrcpit1 P_ARG2(a, b)
1607
#define PFRSQIT1(a, b)          pfrsqit1 P_ARG2(a, b)
1608
#define PFRCPIT2(a, b)          pfrcpit2 P_ARG2(a, b)
1609
#define PMULHRW(a, b)           pmulhrw P_ARG2(a, b)
1610
 
1611
#define FEMMS                   femms
1612
#define PREFETCH(a)             prefetch P_ARG1(a)
1613
#define PREFETCHW(a)            prefetchw P_ARG1(a)
1614
 
1615
/* Intel SSE */
1616
#define ADDPS(a, b)             addps P_ARG2(a, b)
1617
#define ADDSS(a, b)             addss P_ARG2(a, b)
1618
#define ANDNPS(a, b)            andnps P_ARG2(a, b)
1619
#define ANDPS(a, b)             andps P_ARG2(a, b)
1620
/* NASM only knows the pseudo ops for these.
1621
#define CMPPS(a, b, c)          cmpps P_ARG3(a, b, c)
1622
#define CMPSS(a, b, c)          cmpss P_ARG3(a, b, c)
1623
*/
1624
#define CMPEQPS(a, b)           cmpeqps P_ARG2(a, b)
1625
#define CMPLTPS(a, b)           cmpltps P_ARG2(a, b)
1626
#define CMPLEPS(a, b)           cmpleps P_ARG2(a, b)
1627
#define CMPUNORDPS(a, b)        cmpunordps P_ARG2(a, b)
1628
#define CMPNEQPS(a, b)          cmpneqps P_ARG2(a, b)
1629
#define CMPNLTPS(a, b)          cmpnltps P_ARG2(a, b)
1630
#define CMPNLEPS(a, b)          cmpnleps P_ARG2(a, b)
1631
#define CMPORDPS(a, b)          cmpordps P_ARG2(a, b)
1632
#define CMPEQSS(a, b)           cmpeqss P_ARG2(a, b)
1633
#define CMPLTSS(a, b)           cmpltss P_ARG2(a, b)
1634
#define CMPLESS(a, b)           cmpless P_ARG2(a, b)
1635
#define CMPUNORDSS(a, b)        cmpunordss P_ARG2(a, b)
1636
#define CMPNEQSS(a, b)          cmpneqss P_ARG2(a, b)
1637
#define CMPNLTSS(a, b)          cmpnltss P_ARG2(a, b)
1638
#define CMPNLESS(a, b)          cmpnless P_ARG2(a, b)
1639
#define CMPORDSS(a, b)          cmpordss P_ARG2(a, b)
1640
#define COMISS(a, b)            comiss P_ARG2(a, b)
1641
#define CVTPI2PS(a, b)          cvtpi2ps P_ARG2(a, b)
1642
#define CVTPS2PI(a, b)          cvtps2pi P_ARG2(a, b)
1643
#define CVTSI2SS(a, b)          cvtsi2ss P_ARG2(a, b)
1644
#define CVTSS2SI(a, b)          cvtss2si P_ARG2(a, b)
1645
#define CVTTPS2PI(a, b)         cvttps2pi P_ARG2(a, b)
1646
#define CVTTSS2SI(a, b)         cvttss2si P_ARG2(a, b)
1647
#define DIVPS(a, b)             divps P_ARG2(a, b)
1648
#define DIVSS(a, b)             divss P_ARG2(a, b)
1649
#define FXRSTOR(a)              fxrstor P_ARG1(a)
1650
#define FXSAVE(a)               fxsave P_ARG1(a)
1651
#define LDMXCSR(a)              ldmxcsr P_ARG1(a)
1652
#define MAXPS(a, b)             maxps P_ARG2(a, b)
1653
#define MAXSS(a, b)             maxss P_ARG2(a, b)
1654
#define MINPS(a, b)             minps P_ARG2(a, b)
1655
#define MINSS(a, b)             minss P_ARG2(a, b)
1656
#define MOVAPS(a, b)            movaps P_ARG2(a, b)
1657
#define MOVHLPS(a, b)           movhlps P_ARG2(a, b)
1658
#define MOVHPS(a, b)            movhps P_ARG2(a, b)
1659
#define MOVLHPS(a, b)           movlhps P_ARG2(a, b)
1660
#define MOVLPS(a, b)            movlps P_ARG2(a, b)
1661
#define MOVMSKPS(a, b)          movmskps P_ARG2(a, b)
1662
#define MOVNTPS(a, b)           movntps P_ARG2(a, b)
1663
#define MOVNTQ(a, b)            movntq P_ARG2(a, b)
1664
#define MOVSS(a, b)             movss P_ARG2(a, b)
1665
#define MOVUPS(a, b)            movups P_ARG2(a, b)
1666
#define MULPS(a, b)             mulps P_ARG2(a, b)
1667
#define MULSS(a, b)             mulss P_ARG2(a, b)
1668
#define ORPS(a, b)              orps P_ARG2(a, b)
1669
#define RCPPS(a, b)             rcpps P_ARG2(a, b)
1670
#define RCPSS(a, b)             rcpss P_ARG2(a, b)
1671
#define RSQRTPS(a, b)           rsqrtps P_ARG2(a, b)
1672
#define RSQRTSS(a, b)           rsqrtss P_ARG2(a, b)
1673
#define SHUFPS(a, b, c)         shufps P_ARG3(a, b, c)
1674
#define SQRTPS(a, b)            sqrtps P_ARG2(a, b)
1675
#define SQRTSS(a, b)            sqrtss P_ARG2(a, b)
1676
#define STMXCSR(a)              stmxcsr P_ARG1(a)
1677
#define SUBPS(a, b)             subps P_ARG2(a, b)
1678
#define UCOMISS(a, b)           ucomiss P_ARG2(a, b)
1679
#define UNPCKHPS(a, b)          unpckhps P_ARG2(a, b)
1680
#define UNPCKLPS(a, b)          unpcklps P_ARG2(a, b)
1681
#define XORPS(a, b)             xorps P_ARG2(a, b)
1682
 
1683
#define PREFETCHNTA(a)          prefetchnta P_ARG1(a)
1684
#define PREFETCHT0(a)           prefetcht0 P_ARG1(a)
1685
#define PREFETCHT1(a)           prefetcht1 P_ARG1(a)
1686
#define PREFETCHT2(a)           prefetcht2 P_ARG1(a)
1687
#define SFENCE                  sfence
1688
 
1689
/* Added by BrianP for FreeBSD (per David Dawes) */
1690
#if !defined(NASM_ASSEMBLER) && !defined(MASM_ASSEMBLER) && !defined(__bsdi__)
1691
#define LLBL(a)         CONCAT(.L,a)
1692
#else
1693
#define LLBL(a)         a
1694
#endif
1695
 
1696
 
1697
#endif /* __ASSYNTAX_H__ */