Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/trunk/src/runtime/mach-dep/assyntax.h
ViewVC logotype

Annotation of /sml/trunk/src/runtime/mach-dep/assyntax.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1186 - (view) (download) (as text)

1 : monnier 437
2 : blume 1186 #ifndef __ASSYNTAX_H__
3 :     #define __ASSYNTAX_H__
4 : monnier 437
5 :     /*
6 :     * Copyright 1992 Vrije Universiteit, The Netherlands
7 :     *
8 :     * Permission to use, copy, modify, and distribute this software and its
9 :     * documentation for any purpose and without fee is hereby granted, provided
10 :     * that the above copyright notice appear in all copies and that both that
11 :     * copyright notice and this permission notice appear in supporting
12 :     * documentation, and that the name of the Vrije Universiteit not be used in
13 :     * advertising or publicity pertaining to distribution of the software without
14 :     * specific, written prior permission. The Vrije Universiteit makes no
15 :     * representations about the suitability of this software for any purpose.
16 :     * It is provided "as is" without express or implied warranty.
17 :     *
18 : blume 1186 * The Vrije Universiteit DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
19 :     * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
20 :     * IN NO EVENT SHALL The Vrije Universiteit BE LIABLE FOR ANY SPECIAL,
21 :     * INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
22 :     * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
23 :     * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
24 : monnier 437 * PERFORMANCE OF THIS SOFTWARE.
25 :     */
26 : blume 1186 /* $XFree86: xc/extras/Mesa/src/X86/assyntax.h,v 1.10 2002/03/05 20:27:24 dawes Exp $ */
27 : monnier 437
28 : blume 1186 /*
29 : monnier 437 * 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 : blume 1186 * (a) AT&T SysVr4 as(1): define ATT_ASSEMBLER
46 :     * (b) GNU Assembler gas: define GNU_ASSEMBLER (default)
47 : monnier 437 * (c) Amsterdam Compiler kit: define ACK_ASSEMBLER
48 : blume 1186 * (d) The Netwide Assembler: define NASM_ASSEMBLER
49 :     * (e) Microsoft Assembler: define MASM_ASSEMBLER (UNTESTED!)
50 : monnier 437 *
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 : blume 1186 *
67 :     * [support for Intel syntax added by Josh Vanderhoof, 1999]
68 : monnier 437 */
69 :    
70 : blume 1186 #if !(defined(NASM_ASSEMBLER) || defined(MASM_ASSEMBLER))
71 : monnier 437
72 : blume 1186 /* 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 : monnier 437 #define GNU_ASSEMBLER
79 :     #endif
80 :    
81 : blume 1186 #if (defined(__STDC__) && !defined(UNIXCPP)) || (defined (sun) && defined (i386) && defined (SVR4) && defined (__STDC__) && !defined (__GNUC__))
82 :     #define CONCAT(x, y) x ## y
83 : monnier 437 #else
84 : blume 1186 #define CONCAT(x, y) x/**/y
85 : monnier 437 #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 : blume 1186 #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 : monnier 437 /* Control Registers */
123 : blume 1186 #define CR0 cr0
124 :     #define CR1 cr1
125 :     #define CR2 cr2
126 :     #define CR3 cr3
127 : monnier 437 /* Debug Registers */
128 : blume 1186 #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 : monnier 437 /* Floating-point Stack */
137 : blume 1186 #define ST st
138 : monnier 437
139 : blume 1186 #define AS_BEGIN .sect .text; .sect .rom; .sect .data; .sect .bss; .sect .text
140 : monnier 437
141 :    
142 : blume 1186 #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 : monnier 437
149 : blume 1186 #define CHOICE(a,b,c) c
150 : monnier 437
151 :     #else /* AT&T or GAS */
152 :    
153 :     /* Redefine register names for GAS & AT&T assemblers */
154 : blume 1186 #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 : monnier 437 /* Control Registers */
185 : blume 1186 #define CR0 %cr0
186 :     #define CR1 %cr1
187 :     #define CR2 %cr2
188 :     #define CR3 %cr3
189 : monnier 437 /* Debug Registers */
190 : blume 1186 #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 : monnier 437 /* Floating-point Stack */
199 : blume 1186 #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 : monnier 437
232 : blume 1186 #define AS_BEGIN
233 :     #define USE16
234 :     #define USE32
235 : monnier 437
236 :     #ifdef GNU_ASSEMBLER
237 :    
238 : blume 1186 #define ADDR_TOGGLE aword
239 :     #define OPSZ_TOGGLE word
240 : monnier 437
241 : blume 1186 #define CHOICE(a,b,c) b
242 : monnier 437
243 :     #else
244 :     /*
245 :     * AT&T ASSEMBLER SYNTAX
246 :     * *********************
247 :     */
248 : blume 1186 #define CHOICE(a,b,c) a
249 : monnier 437
250 : blume 1186 #define ADDR_TOGGLE addr16
251 :     #define OPSZ_TOGGLE data16
252 : monnier 437
253 :     #endif /* GNU_ASSEMBLER */
254 :     #endif /* ACK_ASSEMBLER */
255 :    
256 :    
257 : blume 1186 #if defined(__QNX__) || defined(Lynx) || (defined(SYSV) || defined(SVR4)) && !defined(ACK_ASSEMBLER) || defined(__ELF__) || defined(__GNU__) || defined(__GNUC__)
258 :     #define GLNAME(a) a
259 : monnier 437 #else
260 : blume 1186 #define GLNAME(a) CONCAT(_,a)
261 : monnier 437 #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 : blume 1186 #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 : monnier 437 /* 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 : blume 1186 #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 : monnier 437
307 :     #ifdef GNU_ASSEMBLER
308 : blume 1186 #define D_SPACE(n) . = . + n
309 : monnier 437 #else
310 : blume 1186 #define D_SPACE(n) .space n
311 : monnier 437 #endif
312 :    
313 :     /* Addressing Modes */
314 :     /* Immediate Mode */
315 : blume 1186 #define ADDR(a) CHOICE(CONCAT($,a), CONCAT($,a), a)
316 :     #define CONST(a) CHOICE(CONCAT($,a), CONCAT($,a), a)
317 : monnier 437
318 :     /* Indirect Mode */
319 : blume 1186 #define CONTENT(a) CHOICE(a, a, (a)) /* take contents of variable */
320 :     #define REGIND(a) CHOICE((a), (a), (a)) /* Register a indirect */
321 : monnier 437 /* Register b indirect plus displacement a */
322 : blume 1186 #define REGOFF(a, b) CHOICE(a(b), a(b), a(b))
323 : monnier 437 /* Reg indirect Base + Index + Displacement - this is mainly for 16-bit mode
324 :     * which has no scaling
325 :     */
326 : blume 1186 #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 : monnier 437 /* Reg indirect Base + (Index * Scale) + Displacement */
330 : blume 1186 #define REGBISD(b,i,s,d) CHOICE(d(b,i,s), d(b,i,s), d(b)(i*s))
331 : monnier 437 /* 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 : blume 1186 #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 : monnier 437
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 : blume 1186 #define ARG2(a, b) a,b
358 :     #define ARG3(a,b,c) a,b,c
359 : monnier 437
360 :     /* Redefine assembler commands */
361 : blume 1186 #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 : monnier 437 /* More forms than this for imul!! */
420 : blume 1186 #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 : monnier 437 /* 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 : blume 1186 #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 : monnier 437 #else
434 : blume 1186 #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 : monnier 437 #endif
438 : blume 1186 #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 : monnier 437 #if !defined(_REAL_MODE) && !defined(_V86_MODE)
483 : blume 1186 #define LAR(a, b) CHOICE(lar ARG2(a, b), lar ARG2(a, b), lar ARG2(b, a))
484 : monnier 437 #endif
485 : blume 1186 #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 : monnier 437 #define LOCK CHOICE(lock, lock, lock)
498 : blume 1186 #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 : monnier 437 #if !defined(_REAL_MODE) && !defined(_V86_MODE)
507 : blume 1186 #define LSL(a, b) CHOICE(lsl ARG2(a,b), lsl ARG2(a,b), lsl ARG2(b,a))
508 : monnier 437 #endif
509 : blume 1186 #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 : monnier 437 /* 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 : blume 1186 #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 : monnier 437
666 :    
667 :     /* Floating Point Instructions */
668 : blume 1186 #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 : monnier 437
784 : blume 1186 /* 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 : monnier 437
788 : blume 1186 #else /* NASM_ASSEMBLER || MASM_ASSEMBLER is defined */
789 : monnier 437
790 : blume 1186 /****************************************/
791 :     /* */
792 :     /* Intel style assemblers. */
793 :     /* (NASM and MASM) */
794 :     /* */
795 :     /****************************************/
796 : monnier 437
797 : blume 1186 #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 : monnier 437
803 : blume 1186 #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 : monnier 437
809 : blume 1186 #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 : monnier 437
815 : blume 1186 #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 : monnier 437
821 : blume 1186 #define P_EBP EBP
822 :     #define L_EBP EBP
823 :     #define W_BP BP
824 : monnier 437
825 : blume 1186 #define P_ESI ESI
826 :     #define L_ESI ESI
827 :     #define W_SI SI
828 : monnier 437
829 : blume 1186 #define P_EDI EDI
830 :     #define L_EDI EDI
831 :     #define W_DI DI
832 : monnier 437
833 : blume 1186 #define P_ESP ESP
834 :     #define L_ESP ESP
835 :     #define W_SP SP
836 : monnier 437
837 : blume 1186 #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 : monnier 437
844 : blume 1186 #define X_ST ST
845 :     #define D_ST ST
846 :     #define L_ST ST
847 : monnier 437
848 : blume 1186 #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 : monnier 437 #define FILE(s)
897 : blume 1186 #define STRING(s) db s
898 :     #define D_LONG dd
899 :     #define D_WORD dw
900 :     #define D_BYTE db
901 : monnier 437 /* #define SPACE */
902 :     /* #define COMM */
903 : blume 1186 #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 : monnier 437
915 : blume 1186 #define D_SPACE(n) db n REP 0
916 : monnier 437
917 :     #define AS_BEGIN
918 :    
919 : blume 1186 /* 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) _ ## a
972 :     #endif
973 :    
974 : monnier 437 /*
975 : blume 1186 * Addressing Modes
976 : monnier 437 */
977 :    
978 :     /* Immediate Mode */
979 : blume 1186 #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 : monnier 437
986 : blume 1186 #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 : monnier 437
993 :     /* Indirect Mode */
994 : blume 1186 #define P_CONTENT(a) a
995 :     #define X_CONTENT(a) TBYTE_PTR a
996 :     #define D_CONTENT(a) QWORD_PTR a
997 :     #define L_CONTENT(a) DWORD_PTR a
998 :     #define W_CONTENT(a) WORD_PTR a
999 :     #define B_CONTENT(a) BYTE_PTR a
1000 : monnier 437
1001 :     /* Register a indirect */
1002 : blume 1186 #define P_REGIND(a) [a]
1003 :     #define X_REGIND(a) TBYTE_PTR [a]
1004 :     #define D_REGIND(a) QWORD_PTR [a]
1005 :     #define L_REGIND(a) DWORD_PTR [a]
1006 :     #define W_REGIND(a) WORD_PTR [a]
1007 :     #define B_REGIND(a) BYTE_PTR [a]
1008 : monnier 437
1009 :     /* Register b indirect plus displacement a */
1010 : blume 1186 #define P_REGOFF(a, b) [b + a]
1011 :     #define X_REGOFF(a, b) TBYTE_PTR [b + a]
1012 :     #define D_REGOFF(a, b) QWORD_PTR [b + a]
1013 :     #define L_REGOFF(a, b) DWORD_PTR [b + a]
1014 :     #define W_REGOFF(a, b) WORD_PTR [b + a]
1015 :     #define B_REGOFF(a, b) BYTE_PTR [b + a]
1016 : monnier 437
1017 :     /* Reg indirect Base + Index + Displacement - this is mainly for 16-bit mode
1018 :     * which has no scaling
1019 :     */
1020 : blume 1186 #define P_REGBID(b, i, d) [b + i + d]
1021 :     #define X_REGBID(b, i, d) TBYTE_PTR [b + i + d]
1022 :     #define D_REGBID(b, i, d) QWORD_PTR [b + i + d]
1023 :     #define L_REGBID(b, i, d) DWORD_PTR [b + i + d]
1024 :     #define W_REGBID(b, i, d) WORD_PTR [b + i + d]
1025 :     #define B_REGBID(b, i, d) BYTE_PTR [b + i + d]
1026 : monnier 437
1027 : blume 1186 /* Reg indirect Base + (Index * Scale) */
1028 :     #define P_REGBIS(b, i, s) [b + i * s]
1029 :     #define X_REGBIS(b, i, s) TBYTE_PTR [b + i * s]
1030 :     #define D_REGBIS(b, i, s) QWORD_PTR [b + i * s]
1031 :     #define L_REGBIS(b, i, s) DWORD_PTR [b + i * s]
1032 :     #define W_REGBIS(b, i, s) WORD_PTR [b + i * s]
1033 :     #define B_REGBIS(b, i, s) BYTE_PTR [b + i * s]
1034 :    
1035 : monnier 437 /* Reg indirect Base + (Index * Scale) + Displacement */
1036 : blume 1186 #define P_REGBISD(b, i, s, d) [b + i * s + d]
1037 :     #define X_REGBISD(b, i, s, d) TBYTE_PTR [b + i * s + d]
1038 :     #define D_REGBISD(b, i, s, d) QWORD_PTR [b + i * s + d]
1039 :     #define L_REGBISD(b, i, s, d) DWORD_PTR [b + i * s + d]
1040 :     #define W_REGBISD(b, i, s, d) WORD_PTR [b + i * s + d]
1041 :     #define B_REGBISD(b, i, s, d) BYTE_PTR [b + i * s + d]
1042 : monnier 437
1043 :     /* Displaced Scaled Index: */
1044 : blume 1186 #define P_REGDIS(d, i, s) [i * s + d]
1045 :     #define X_REGDIS(d, i, s) TBYTE_PTR [i * s + d]
1046 :     #define D_REGDIS(d, i, s) QWORD_PTR [i * s + d]
1047 :     #define L_REGDIS(d, i, s) DWORD_PTR [i * s + d]
1048 :     #define W_REGDIS(d, i, s) WORD_PTR [i * s + d]
1049 :     #define B_REGDIS(d, i, s) BYTE_PTR [i * s + d]
1050 : monnier 437
1051 :     /* Indexed Base: */
1052 : blume 1186 #define P_REGBI(b, i) [b + i]
1053 :     #define X_REGBI(b, i) TBYTE_PTR [b + i]
1054 :     #define D_REGBI(b, i) QWORD_PTR [b + i]
1055 :     #define L_REGBI(b, i) DWORD_PTR [b + i]
1056 :     #define W_REGBI(b, i) WORD_PTR [b + i]
1057 :     #define B_REGBI(b, i) BYTE_PTR [b + i]
1058 : monnier 437
1059 :     /* Displaced Base: */
1060 : blume 1186 #define P_REGDB(d, b) [b + d]
1061 :     #define X_REGDB(d, b) TBYTE_PTR [b + d]
1062 :     #define D_REGDB(d, b) QWORD_PTR [b + d]
1063 :     #define L_REGDB(d, b) DWORD_PTR [b + d]
1064 :     #define W_REGDB(d, b) WORD_PTR [b + d]
1065 :     #define B_REGDB(d, b) BYTE_PTR [b + d]
1066 : monnier 437
1067 :     /* Variable indirect: */
1068 : blume 1186 #define VARINDIRECT(var) var
1069 : monnier 437
1070 :     /* Use register contents as jump/call target: */
1071 : blume 1186 #define CODEPTR(reg) reg
1072 : monnier 437
1073 :     /*
1074 : blume 1186 * Redefine assembler commands
1075 : monnier 437 */
1076 :    
1077 : blume 1186 #define P_(a) P_ ## a
1078 :     #define X_(a) X_ ## a
1079 :     #define D_(a) D_ ## a
1080 :     #define S_(a) L_ ## a
1081 :     #define L_(a) L_ ## a
1082 :     #define W_(a) W_ ## a
1083 :     #define B_(a) B_ ## a
1084 : monnier 437
1085 : blume 1186 #define AAA aaa
1086 :     #define AAD aad
1087 :     #define AAM aam
1088 :     #define AAS aas
1089 :     #define ADC_L(a, b) adc L_(b), L_(a)
1090 :     #define ADC_W(a, b) adc W_(b), W_(a)
1091 :     #define ADC_B(a, b) adc B_(b), B_(a)
1092 :     #define ADD_L(a, b) add L_(b), L_(a)
1093 :     #define ADD_W(a, b) add W_(b), W_(a)
1094 :     #define ADD_B(a, b) add B_(b), B_(a)
1095 :     #define AND_L(a, b) and L_(b), L_(a)
1096 :     #define AND_W(a, b) and W_(b), W_(a)
1097 :     #define AND_B(a, b) and B_(b), B_(a)
1098 :     #define ARPL(a,b) arpl W_(b), a
1099 :     #define BOUND_L(a, b) bound L_(b), L_(a)
1100 :     #define BOUND_W(a, b) bound W_(b), W_(a)
1101 :     #define BSF_L(a, b) bsf L_(b), L_(a)
1102 :     #define BSF_W(a, b) bsf W_(b), W_(a)
1103 :     #define BSR_L(a, b) bsr L_(b), L_(a)
1104 :     #define BSR_W(a, b) bsr W_(b), W_(a)
1105 :     #define BT_L(a, b) bt L_(b), L_(a)
1106 :     #define BT_W(a, b) bt W_(b), W_(a)
1107 :     #define BTC_L(a, b) btc L_(b), L_(a)
1108 :     #define BTC_W(a, b) btc W_(b), W_(a)
1109 :     #define BTR_L(a, b) btr L_(b), L_(a)
1110 :     #define BTR_W(a, b) btr W_(b), W_(a)
1111 :     #define BTS_L(a, b) bts L_(b), L_(a)
1112 :     #define BTS_W(a, b) bts W_(b), W_(a)
1113 :     #define CALL(a) call a
1114 :     #define CALLF(s,a) call far s:a
1115 :     #define CBW cbw
1116 :     #define CWDE cwde
1117 :     #define CLC clc
1118 :     #define CLD cld
1119 :     #define CLI cli
1120 :     #define CLTS clts
1121 :     #define CMC cmc
1122 :     #define CMP_L(a, b) cmp L_(b), L_(a)
1123 :     #define CMP_W(a, b) cmp W_(b), W_(a)
1124 :     #define CMP_B(a, b) cmp B_(b), B_(a)
1125 :     #define CMPS_L cmpsd
1126 :     #define CMPS_W cmpsw
1127 :     #define CMPS_B cmpsb
1128 :     #define CPUID cpuid
1129 :     #define CWD cwd
1130 :     #define CDQ cdq
1131 :     #define DAA daa
1132 :     #define DAS das
1133 :     #define DEC_L(a) dec L_(a)
1134 :     #define DEC_W(a) dec W_(a)
1135 :     #define DEC_B(a) dec B_(a)
1136 :     #define DIV_L(a) div L_(a)
1137 :     #define DIV_W(a) div W_(a)
1138 :     #define DIV_B(a) div B_(a)
1139 :     #define ENTER(a,b) enter b, a
1140 :     #define HLT hlt
1141 :     #define IDIV_L(a) idiv L_(a)
1142 :     #define IDIV_W(a) idiv W_(a)
1143 :     #define IDIV_B(a) idiv B_(a)
1144 :     #define IMUL_L(a, b) imul L_(b), L_(a)
1145 :     #define IMUL_W(a, b) imul W_(b), W_(a)
1146 :     #define IMUL_B(a) imul B_(a)
1147 :     #define IN_L in EAX, DX
1148 :     #define IN_W in AX, DX
1149 :     #define IN_B in AL, DX
1150 :     #define IN1_L(a) in1 L_(a)
1151 :     #define IN1_W(a) in1 W_(a)
1152 :     #define IN1_B(a) in1 B_(a)
1153 :     #define INC_L(a) inc L_(a)
1154 :     #define INC_W(a) inc W_(a)
1155 :     #define INC_B(a) inc B_(a)
1156 :     #define INS_L ins
1157 :     #define INS_W ins
1158 :     #define INS_B ins
1159 :     #define INT(a) int B_(a)
1160 :     #define INT3 int3
1161 :     #define INTO into
1162 :     #define IRET iret
1163 :     #define IRETD iretd
1164 :     #define JA(a) ja NEAR a
1165 :     #define JAE(a) jae NEAR a
1166 :     #define JB(a) jb NEAR a
1167 :     #define JBE(a) jbe NEAR a
1168 :     #define JC(a) jc NEAR a
1169 :     #define JE(a) je NEAR a
1170 :     #define JG(a) jg NEAR a
1171 :     #define JGE(a) jge NEAR a
1172 :     #define JL(a) jl NEAR a
1173 :     #define JLE(a) jle NEAR a
1174 :     #define JNA(a) jna NEAR a
1175 :     #define JNAE(a) jnae NEAR a
1176 :     #define JNB(a) jnb NEAR a
1177 :     #define JNBE(a) jnbe NEAR a
1178 :     #define JNC(a) jnc NEAR a
1179 :     #define JNE(a) jne NEAR a
1180 :     #define JNG(a) jng NEAR a
1181 :     #define JNGE(a) jnge NEAR a
1182 :     #define JNL(a) jnl NEAR a
1183 :     #define JNLE(a) jnle NEAR a
1184 :     #define JNO(a) jno NEAR a
1185 :     #define JNP(a) jnp NEAR a
1186 :     #define JNS(a) jns NEAR a
1187 :     #define JNZ(a) jnz NEAR a
1188 :     #define JO(a) jo NEAR a
1189 :     #define JP(a) jp NEAR a
1190 :     #define JPE(a) jpe NEAR a
1191 :     #define JPO(a) jpo NEAR a
1192 :     #define JS(a) js NEAR a
1193 :     #define JZ(a) jz NEAR a
1194 :     #define JMP(a) jmp a
1195 :     #define JMPF(s,a) jmpf
1196 :     #define LAHF lahf
1197 :     #define LAR(a, b) lar b, a
1198 :     #define LEA_L(a, b) lea P_(b), P_(a)
1199 :     #define LEA_W(a, b) lea P_(b), P_(a)
1200 :     #define LEAVE leave
1201 :     #define LGDT(a) lgdt a
1202 :     #define LIDT(a) lidt a
1203 :     #define LDS(a, b) lds b, a
1204 :     #define LES(a, b) les b, a
1205 :     #define LFS(a, b) lfs b, a
1206 :     #define LGS(a, b) lgs b, a
1207 :     #define LSS(a, b) lss b, a
1208 :     #define LLDT(a) lldt a
1209 :     #define LMSW(a) lmsw a
1210 :     #define LOCK lock
1211 :     #define LODS_L lodsd
1212 :     #define LODS_W lodsw
1213 :     #define LODS_B lodsb
1214 :     #define LOOP(a) loop a
1215 :     #define LOOPE(a) loope a
1216 :     #define LOOPZ(a) loopz a
1217 :     #define LOOPNE(a) loopne a
1218 :     #define LOOPNZ(a) loopnz a
1219 :     #define LSL(a, b) lsl b, a
1220 :     #define LTR(a) ltr a
1221 :     #define MOV_SR(a, b) mov S_(b), S_(a)
1222 :     #define MOV_L(a, b) mov L_(b), L_(a)
1223 :     #define MOV_W(a, b) mov W_(b), W_(a)
1224 :     #define MOV_B(a, b) mov B_(b), B_(a)
1225 :     #define MOVS_L movsd
1226 :     #define MOVS_W movsw
1227 :     #define MOVS_B movsb
1228 :     #define MOVSX_BL(a, b) movsx B_(b), B_(a)
1229 :     #define MOVSX_BW(a, b) movsx B_(b), B_(a)
1230 :     #define MOVSX_WL(a, b) movsx W_(b), W_(a)
1231 :     #define MOVZX_BL(a, b) movzx B_(b), B_(a)
1232 :     #define MOVZX_BW(a, b) movzx B_(b), B_(a)
1233 :     #define MOVZX_WL(a, b) movzx W_(b), W_(a)
1234 :     #define MUL_L(a) mul L_(a)
1235 :     #define MUL_W(a) mul W_(a)
1236 :     #define MUL_B(a) mul B_(a)
1237 :     #define NEG_L(a) neg L_(a)
1238 :     #define NEG_W(a) neg W_(a)
1239 :     #define NEG_B(a) neg B_(a)
1240 :     #define NOP nop
1241 :     #define NOT_L(a) not L_(a)
1242 :     #define NOT_W(a) not W_(a)
1243 :     #define NOT_B(a) not B_(a)
1244 :     #define OR_L(a,b) or L_(b), L_(a)
1245 :     #define OR_W(a,b) or W_(b), W_(a)
1246 :     #define OR_B(a,b) or B_(b), B_(a)
1247 :     #define OUT_L out DX, EAX
1248 :     #define OUT_W out DX, AX
1249 :     #define OUT_B out DX, AL
1250 :     #define OUT1_L(a) out1 L_(a)
1251 :     #define OUT1_W(a) out1 W_(a)
1252 :     #define OUT1_B(a) out1 B_(a)
1253 :     #define OUTS_L outsd
1254 :     #define OUTS_W outsw
1255 :     #define OUTS_B outsb
1256 :     #define POP_SR(a) pop S_(a)
1257 :     #define POP_L(a) pop L_(a)
1258 :     #define POP_W(a) pop W_(a)
1259 :     #define POPA_L popad
1260 :     #define POPA_W popa
1261 :     #define POPF_L popfd
1262 :     #define POPF_W popf
1263 :     #define PUSH_SR(a) push S_(a)
1264 :     #define PUSH_L(a) push L_(a)
1265 :     #define PUSH_W(a) push W_(a)
1266 :     #define PUSH_B(a) push B_(a)
1267 :     #define PUSHA_L pushad
1268 :     #define PUSHA_W pusha
1269 :     #define PUSHF_L pushfd
1270 :     #define PUSHF_W pushf
1271 :     #define RCL_L(a, b) rcl L_(b), L_(a)
1272 :     #define RCL_W(a, b) rcl W_(b), W_(a)
1273 :     #define RCL_B(a, b) rcl B_(b), B_(a)
1274 :     #define RCR_L(a, b) rcr L_(b), L_(a)
1275 :     #define RCR_W(a, b) rcr W_(b), W_(a)
1276 :     #define RCR_B(a, b) rcr B_(b), B_(a)
1277 :     #define RDTSC rdtsc
1278 :     #define ROL_L(a, b) rol L_(b), L_(a)
1279 :     #define ROL_W(a, b) rol W_(b), W_(a)
1280 :     #define ROL_B(a, b) rol B_(b), B_(a)
1281 :     #define ROR_L(a, b) ror L_(b), L_(a)
1282 :     #define ROR_W(a, b) ror W_(b), W_(a)
1283 :     #define ROR_B(a, b) ror B_(b), B_(a)
1284 :     #define REP rep
1285 :     #define REPE repe
1286 :     #define REPNE repne
1287 :     #define REPNZ REPNE
1288 :     #define REPZ REPE
1289 :     #define RET ret
1290 :     #define SAHF sahf
1291 :     #define SAL_L(a, b) sal L_(b), L_(a)
1292 :     #define SAL_W(a, b) sal W_(b), W_(a)
1293 :     #define SAL_B(a, b) sal B_(b), B_(a)
1294 :     #define SAR_L(a, b) sar L_(b), L_(a)
1295 :     #define SAR_W(a, b) sar W_(b), W_(a)
1296 :     #define SAR_B(a, b) sar B_(b), B_(a)
1297 :     #define SBB_L(a, b) sbb L_(b), L_(a)
1298 :     #define SBB_W(a, b) sbb W_(b), W_(a)
1299 :     #define SBB_B(a, b) sbb B_(b), B_(a)
1300 :     #define SCAS_L scas
1301 :     #define SCAS_W scas
1302 :     #define SCAS_B scas
1303 :     #define SETA(a) seta a
1304 :     #define SETAE(a) setae a
1305 :     #define SETB(a) setb a
1306 :     #define SETBE(a) setbe a
1307 :     #define SETC(a) setc a
1308 :     #define SETE(a) sete a
1309 :     #define SETG(a) setg a
1310 :     #define SETGE(a) setge a
1311 :     #define SETL(a) setl a
1312 :     #define SETLE(a) setle a
1313 :     #define SETNA(a) setna a
1314 :     #define SETNAE(a) setnae a
1315 :     #define SETNB(a) setnb a
1316 :     #define SETNBE(a) setnbe a
1317 :     #define SETNC(a) setnc a
1318 :     #define SETNE(a) setne a
1319 :     #define SETNG(a) setng a
1320 :     #define SETNGE(a) setnge a
1321 :     #define SETNL(a) setnl a
1322 :     #define SETNLE(a) setnle a
1323 :     #define SETNO(a) setno a
1324 :     #define SETNP(a) setnp a
1325 :     #define SETNS(a) setns a
1326 :     #define SETNZ(a) setnz a
1327 :     #define SETO(a) seto a
1328 :     #define SETP(a) setp a
1329 :     #define SETPE(a) setpe a
1330 :     #define SETPO(a) setpo a
1331 :     #define SETS(a) sets a
1332 :     #define SETZ(a) setz a
1333 :     #define SGDT(a) sgdt a
1334 :     #define SIDT(a) sidt a
1335 :     #define SHL_L(a, b) shl L_(b), L_(a)
1336 :     #define SHL_W(a, b) shl W_(b), W_(a)
1337 :     #define SHL_B(a, b) shl B_(b), B_(a)
1338 :     #define SHLD_L(a,b,c) shld
1339 :     #define SHLD2_L(a,b) shld L_(b), L_(a)
1340 :     #define SHLD_W(a,b,c) shld
1341 :     #define SHLD2_W(a,b) shld W_(b), W_(a)
1342 :     #define SHR_L(a, b) shr L_(b), L_(a)
1343 :     #define SHR_W(a, b) shr W_(b), W_(a)
1344 :     #define SHR_B(a, b) shr B_(b), B_(a)
1345 :     #define SHRD_L(a,b,c) shrd
1346 :     #define SHRD2_L(a,b) shrd L_(b), L_(a)
1347 :     #define SHRD_W(a,b,c) shrd
1348 :     #define SHRD2_W(a,b) shrd W_(b), W_(a)
1349 :     #define SLDT(a) sldt a
1350 :     #define SMSW(a) smsw a
1351 :     #define STC stc
1352 :     #define STD std
1353 :     #define STI sti
1354 :     #define STOS_L stos
1355 :     #define STOS_W stos
1356 :     #define STOS_B stos
1357 :     #define STR(a) str a
1358 :     #define SUB_L(a, b) sub L_(b), L_(a)
1359 :     #define SUB_W(a, b) sub W_(b), W_(a)
1360 :     #define SUB_B(a, b) sub B_(b), B_(a)
1361 :     #define TEST_L(a, b) test L_(b), L_(a)
1362 :     #define TEST_W(a, b) test W_(b), W_(a)
1363 :     #define TEST_B(a, b) test B_(b), B_(a)
1364 :     #define VERR(a) verr a
1365 :     #define VERW(a) verw a
1366 :     #define WAIT wait
1367 :     #define XCHG_L(a, b) xchg L_(b), L_(a)
1368 :     #define XCHG_W(a, b) xchg W_(b), W_(a)
1369 :     #define XCHG_B(a, b) xchg B_(b), B_(a)
1370 :     #define XLAT xlat
1371 :     #define XOR_L(a, b) xor L_(b), L_(a)
1372 :     #define XOR_W(a, b) xor W_(b), W_(a)
1373 :     #define XOR_B(a, b) xor B_(b), B_(a)
1374 : monnier 437
1375 : blume 1186
1376 :     /* Floating Point Instructions */
1377 :     #define F2XM1 f2xm1
1378 :     #define FABS fabs
1379 :     #define FADD_D(a) fadd D_(a)
1380 :     #define FADD_S(a) fadd S_(a)
1381 :     #define FADD2(a, b) fadd b, a
1382 :     #define FADDP(a, b) faddp b, a
1383 :     #define FIADD_L(a) fiadd L_(a)
1384 :     #define FIADD_W(a) fiadd W_(a)
1385 :     #define FBLD(a) fbld a
1386 :     #define FBSTP(a) fbstp a
1387 :     #define FCHS fchs
1388 :     #define FCLEX fclex
1389 :     #define FNCLEX fnclex
1390 :     #define FCOM(a) fcom a
1391 :     #define FCOM_D(a) fcom D_(a)
1392 :     #define FCOM_S(a) fcom S_(a)
1393 :     #define FCOMP(a) fcomp a
1394 :     #define FCOMP_D(a) fcomp D_(a)
1395 :     #define FCOMP_S(a) fcomp S_(a)
1396 :     #define FCOMPP fcompp
1397 :     #define FCOS fcos
1398 :     #define FDECSTP fdecstp
1399 :     #define FDIV_D(a) fdiv D_(a)
1400 :     #define FDIV_S(a) fdiv S_(a)
1401 :     #define FDIV2(a, b) fdiv b, a
1402 :     #define FDIVP(a, b) fdivp b, a
1403 :     #define FIDIV_L(a) fidiv L_(a)
1404 :     #define FIDIV_W(a) fidiv W_(a)
1405 :     #define FDIVR_D(a) fdivr D_(a)
1406 :     #define FDIVR_S(a) fdivr S_(a)
1407 :     #define FDIVR2(a, b) fdivr b, a
1408 :     #define FDIVRP(a, b) fdivrp b, a
1409 :     #define FIDIVR_L(a) fidivr L_(a)
1410 :     #define FIDIVR_W(a) fidivr W_(a)
1411 :     #define FFREE(a) ffree a
1412 :     #define FICOM_L(a) ficom L_(a)
1413 :     #define FICOM_W(a) ficom W_(a)
1414 :     #define FICOMP_L(a) ficomp L_(a)
1415 :     #define FICOMP_W(a) ficomp W_(a)
1416 :     #define FILD_Q(a) fild D_(a)
1417 :     #define FILD_L(a) fild L_(a)
1418 :     #define FILD_W(a) fild W_(a)
1419 :     #define FINCSTP fincstp
1420 :     #define FINIT finit
1421 :     #define FNINIT fninit
1422 :     #define FIST_L(a) fist L_(a)
1423 :     #define FIST_W(a) fist W_(a)
1424 :     #define FISTP_Q(a) fistp D_(a)
1425 :     #define FISTP_L(a) fistp L_(a)
1426 :     #define FISTP_W(a) fistp W_(a)
1427 :     #define FLD_X(a) fld X_(a)
1428 :     #define FLD_D(a) fld D_(a)
1429 :     #define FLD_S(a) fld S_(a)
1430 :     #define FLD1 fld1
1431 :     #define FLDL2T fldl2t
1432 :     #define FLDL2E fldl2e
1433 :     #define FLDPI fldpi
1434 :     #define FLDLG2 fldlg2
1435 :     #define FLDLN2 fldln2
1436 :     #define FLDZ fldz
1437 :     #define FLDCW(a) fldcw a
1438 :     #define FLDENV(a) fldenv a
1439 :     #define FMUL_S(a) fmul S_(a)
1440 :     #define FMUL_D(a) fmul D_(a)
1441 :     #define FMUL2(a, b) fmul b, a
1442 :     #define FMULP(a, b) fmulp b, a
1443 :     #define FIMUL_L(a) fimul L_(a)
1444 :     #define FIMUL_W(a) fimul W_(a)
1445 :     #define FNOP fnop
1446 :     #define FPATAN fpatan
1447 :     #define FPREM fprem
1448 :     #define FPREM1 fprem1
1449 :     #define FPTAN fptan
1450 :     #define FRNDINT frndint
1451 :     #define FRSTOR(a) frstor a
1452 :     #define FSAVE(a) fsave a
1453 :     #define FNSAVE(a) fnsave a
1454 :     #define FSCALE fscale
1455 :     #define FSIN fsin
1456 :     #define FSINCOS fsincos
1457 :     #define FSQRT fsqrt
1458 :     #define FST_D(a) fst D_(a)
1459 :     #define FST_S(a) fst S_(a)
1460 :     #define FSTP_X(a) fstp X_(a)
1461 :     #define FSTP_D(a) fstp D_(a)
1462 :     #define FSTP_S(a) fstp S_(a)
1463 :     #define FSTP(a) fstp a
1464 :     #define FSTCW(a) fstcw a
1465 :     #define FNSTCW(a) fnstcw a
1466 :     #define FSTENV(a) fstenv a
1467 :     #define FNSTENV(a) fnstenv a
1468 :     #define FSTSW(a) fstsw a
1469 :     #define FNSTSW(a) fnstsw a
1470 :     #define FSUB_S(a) fsub S_(a)
1471 :     #define FSUB_D(a) fsub D_(a)
1472 :     #define FSUB2(a, b) fsub b, a
1473 :     #define FSUBP(a, b) fsubp b, a
1474 :     #define FISUB_L(a) fisub L_(a)
1475 :     #define FISUB_W(a) fisub W_(a)
1476 :     #define FSUBR_S(a) fsubr S_(a)
1477 :     #define FSUBR_D(a) fsubr D_(a)
1478 :     #define FSUBR2(a, b) fsubr b, a
1479 :     #define FSUBRP(a, b) fsubrp b, a
1480 :     #define FISUBR_L(a) fisubr L_(a)
1481 :     #define FISUBR_W(a) fisubr W_(a)
1482 :     #define FTST ftst
1483 :     #define FUCOM(a) fucom a
1484 :     #define FUCOMP(a) fucomp a
1485 :     #define FUCOMPP fucompp
1486 :     #define FWAIT fwait
1487 :     #define FXAM fxam
1488 :     #define FXCH(a) fxch a
1489 :     #define FXTRACT fxtract
1490 :     #define FYL2X fyl2x
1491 :     #define FYL2XP1 fyl2xp1
1492 :    
1493 :     #endif /* NASM_ASSEMBLER, MASM_ASSEMBLER */
1494 :    
1495 :     /****************************************/
1496 :     /* */
1497 :     /* Extensions to x86 insn set - */
1498 :     /* MMX, 3DNow! */
1499 :     /* */
1500 :     /****************************************/
1501 :    
1502 :     #if defined(NASM_ASSEMBLER) || defined(MASM_ASSEMBLER)
1503 :     #define P_ARG1(a) P_ ## a
1504 :     #define P_ARG2(a, b) P_ ## b, P_ ## a
1505 :     #define P_ARG3(a, b, c) P_ ## c, P_ ## b, P_ ## a
1506 :     #else
1507 :     #define P_ARG1(a) a
1508 :     #define P_ARG2(a, b) a, b
1509 :     #define P_ARG3(a, b, c) a, b, c
1510 :     #endif
1511 :    
1512 :     /* MMX */
1513 :     #define MOVD(a, b) movd P_ARG2(a, b)
1514 :     #define MOVQ(a, b) movq P_ARG2(a, b)
1515 :    
1516 :     #define PADDB(a, b) paddb P_ARG2(a, b)
1517 :     #define PADDW(a, b) paddw P_ARG2(a, b)
1518 :     #define PADDD(a, b) paddd P_ARG2(a, b)
1519 :    
1520 :     #define PADDSB(a, b) paddsb P_ARG2(a, b)
1521 :     #define PADDSW(a, b) paddsw P_ARG2(a, b)
1522 :    
1523 :     #define PADDUSB(a, b) paddusb P_ARG2(a, b)
1524 :     #define PADDUSW(a, b) paddusw P_ARG2(a, b)
1525 :    
1526 :     #define PSUBB(a, b) psubb P_ARG2(a, b)
1527 :     #define PSUBW(a, b) psubw P_ARG2(a, b)
1528 :     #define PSUBD(a, b) psubd P_ARG2(a, b)
1529 :    
1530 :     #define PSUBSB(a, b) psubsb P_ARG2(a, b)
1531 :     #define PSUBSW(a, b) psubsw P_ARG2(a, b)
1532 :    
1533 :     #define PSUBUSB(a, b) psubusb P_ARG2(a, b)
1534 :     #define PSUBUSW(a, b) psubusw P_ARG2(a, b)
1535 :    
1536 :     #define PCMPEQB(a, b) pcmpeqb P_ARG2(a, b)
1537 :     #define PCMPEQW(a, b) pcmpeqw P_ARG2(a, b)
1538 :     #define PCMPEQD(a, b) pcmpeqd P_ARG2(a, b)
1539 :    
1540 :     #define PCMPGTB(a, b) pcmpgtb P_ARG2(a, b)
1541 :     #define PCMPGTW(a, b) pcmpgtw P_ARG2(a, b)
1542 :     #define PCMPGTD(a, b) pcmpgtd P_ARG2(a, b)
1543 :    
1544 :     #define PMULHW(a, b) pmulhw P_ARG2(a, b)
1545 :     #define PMULLW(a, b) pmullw P_ARG2(a, b)
1546 :    
1547 :     #define PMADDWD(a, b) pmaddwd P_ARG2(a, b)
1548 :    
1549 :     #define PAND(a, b) pand P_ARG2(a, b)
1550 :    
1551 :     #define PANDN(a, b) pandn P_ARG2(a, b)
1552 :    
1553 :     #define POR(a, b) por P_ARG2(a, b)
1554 :    
1555 :     #define PXOR(a, b) pxor P_ARG2(a, b)
1556 :    
1557 :     #define PSRAW(a, b) psraw P_ARG2(a, b)
1558 :     #define PSRAD(a, b) psrad P_ARG2(a, b)
1559 :    
1560 :     #define PSRLW(a, b) psrlw P_ARG2(a, b)
1561 :     #define PSRLD(a, b) psrld P_ARG2(a, b)
1562 :     #define PSRLQ(a, b) psrlq P_ARG2(a, b)
1563 :    
1564 :     #define PSLLW(a, b) psllw P_ARG2(a, b)
1565 :     #define PSLLD(a, b) pslld P_ARG2(a, b)
1566 :     #define PSLLQ(a, b) psllq P_ARG2(a, b)
1567 :    
1568 :     #define PACKSSWB(a, b) packsswb P_ARG2(a, b)
1569 :     #define PACKSSDW(a, b) packssdw P_ARG2(a, b)
1570 :     #define PACKUSWB(a, b) packuswb P_ARG2(a, b)
1571 :    
1572 :     #define PUNPCKHBW(a, b) punpckhbw P_ARG2(a, b)
1573 :     #define PUNPCKHWD(a, b) punpckhwd P_ARG2(a, b)
1574 :     #define PUNPCKHDQ(a, b) punpckhdq P_ARG2(a, b)
1575 :     #define PUNPCKLBW(a, b) punpcklbw P_ARG2(a, b)
1576 :     #define PUNPCKLWD(a, b) punpcklwd P_ARG2(a, b)
1577 :     #define PUNPCKLDQ(a, b) punpckldq P_ARG2(a, b)
1578 :    
1579 :     #define EMMS emms
1580 :    
1581 :     /* AMD 3DNow! */
1582 :     #define PAVGUSB(a, b) pavgusb P_ARG2(a, b)
1583 :     #define PFADD(a, b) pfadd P_ARG2(a, b)
1584 :     #define PFSUB(a, b) pfsub P_ARG2(a, b)
1585 :     #define PFSUBR(a, b) pfsubr P_ARG2(a, b)
1586 :     #define PFACC(a, b) pfacc P_ARG2(a, b)
1587 :     #define PFCMPGE(a, b) pfcmpge P_ARG2(a, b)
1588 :     #define PFCMPGT(a, b) pfcmpgt P_ARG2(a, b)
1589 :     #define PFCMPEQ(a, b) pfcmpeq P_ARG2(a, b)
1590 :     #define PFMIN(a, b) pfmin P_ARG2(a, b)
1591 :     #define PFMAX(a, b) pfmax P_ARG2(a, b)
1592 :     #define PI2FD(a, b) pi2fd P_ARG2(a, b)
1593 :     #define PF2ID(a, b) pf2id P_ARG2(a, b)
1594 :     #define PFRCP(a, b) pfrcp P_ARG2(a, b)
1595 :     #define PFRSQRT(a, b) pfrsqrt P_ARG2(a, b)
1596 :     #define PFMUL(a, b) pfmul P_ARG2(a, b)
1597 :     #define PFRCPIT1(a, b) pfrcpit1 P_ARG2(a, b)
1598 :     #define PFRSQIT1(a, b) pfrsqit1 P_ARG2(a, b)
1599 :     #define PFRCPIT2(a, b) pfrcpit2 P_ARG2(a, b)
1600 :     #define PMULHRW(a, b) pmulhrw P_ARG2(a, b)
1601 :    
1602 :     #define FEMMS femms
1603 :     #define PREFETCH(a) prefetch P_ARG1(a)
1604 :     #define PREFETCHW(a) prefetchw P_ARG1(a)
1605 :    
1606 :     /* Intel SSE */
1607 :     #define ADDPS(a, b) addps P_ARG2(a, b)
1608 :     #define ADDSS(a, b) addss P_ARG2(a, b)
1609 :     #define ANDNPS(a, b) andnps P_ARG2(a, b)
1610 :     #define ANDPS(a, b) andps P_ARG2(a, b)
1611 :     /* NASM only knows the pseudo ops for these.
1612 :     #define CMPPS(a, b, c) cmpps P_ARG3(a, b, c)
1613 :     #define CMPSS(a, b, c) cmpss P_ARG3(a, b, c)
1614 :     */
1615 :     #define CMPEQPS(a, b) cmpeqps P_ARG2(a, b)
1616 :     #define CMPLTPS(a, b) cmpltps P_ARG2(a, b)
1617 :     #define CMPLEPS(a, b) cmpleps P_ARG2(a, b)
1618 :     #define CMPUNORDPS(a, b) cmpunordps P_ARG2(a, b)
1619 :     #define CMPNEQPS(a, b) cmpneqps P_ARG2(a, b)
1620 :     #define CMPNLTPS(a, b) cmpnltps P_ARG2(a, b)
1621 :     #define CMPNLEPS(a, b) cmpnleps P_ARG2(a, b)
1622 :     #define CMPORDPS(a, b) cmpordps P_ARG2(a, b)
1623 :     #define CMPEQSS(a, b) cmpeqss P_ARG2(a, b)
1624 :     #define CMPLTSS(a, b) cmpltss P_ARG2(a, b)
1625 :     #define CMPLESS(a, b) cmpless P_ARG2(a, b)
1626 :     #define CMPUNORDSS(a, b) cmpunordss P_ARG2(a, b)
1627 :     #define CMPNEQSS(a, b) cmpneqss P_ARG2(a, b)
1628 :     #define CMPNLTSS(a, b) cmpnltss P_ARG2(a, b)
1629 :     #define CMPNLESS(a, b) cmpnless P_ARG2(a, b)
1630 :     #define CMPORDSS(a, b) cmpordss P_ARG2(a, b)
1631 :     #define COMISS(a, b) comiss P_ARG2(a, b)
1632 :     #define CVTPI2PS(a, b) cvtpi2ps P_ARG2(a, b)
1633 :     #define CVTPS2PI(a, b) cvtps2pi P_ARG2(a, b)
1634 :     #define CVTSI2SS(a, b) cvtsi2ss P_ARG2(a, b)
1635 :     #define CVTSS2SI(a, b) cvtss2si P_ARG2(a, b)
1636 :     #define CVTTPS2PI(a, b) cvttps2pi P_ARG2(a, b)
1637 :     #define CVTTSS2SI(a, b) cvttss2si P_ARG2(a, b)
1638 :     #define DIVPS(a, b) divps P_ARG2(a, b)
1639 :     #define DIVSS(a, b) divss P_ARG2(a, b)
1640 :     #define FXRSTOR(a) fxrstor P_ARG1(a)
1641 :     #define FXSAVE(a) fxsave P_ARG1(a)
1642 :     #define LDMXCSR(a) ldmxcsr P_ARG1(a)
1643 :     #define MAXPS(a, b) maxps P_ARG2(a, b)
1644 :     #define MAXSS(a, b) maxss P_ARG2(a, b)
1645 :     #define MINPS(a, b) minps P_ARG2(a, b)
1646 :     #define MINSS(a, b) minss P_ARG2(a, b)
1647 :     #define MOVAPS(a, b) movaps P_ARG2(a, b)
1648 :     #define MOVHLPS(a, b) movhlps P_ARG2(a, b)
1649 :     #define MOVHPS(a, b) movhps P_ARG2(a, b)
1650 :     #define MOVLHPS(a, b) movlhps P_ARG2(a, b)
1651 :     #define MOVLPS(a, b) movlps P_ARG2(a, b)
1652 :     #define MOVMSKPS(a, b) movmskps P_ARG2(a, b)
1653 :     #define MOVNTPS(a, b) movntps P_ARG2(a, b)
1654 :     #define MOVNTQ(a, b) movntq P_ARG2(a, b)
1655 :     #define MOVSS(a, b) movss P_ARG2(a, b)
1656 :     #define MOVUPS(a, b) movups P_ARG2(a, b)
1657 :     #define MULPS(a, b) mulps P_ARG2(a, b)
1658 :     #define MULSS(a, b) mulss P_ARG2(a, b)
1659 :     #define ORPS(a, b) orps P_ARG2(a, b)
1660 :     #define RCPPS(a, b) rcpps P_ARG2(a, b)
1661 :     #define RCPSS(a, b) rcpss P_ARG2(a, b)
1662 :     #define RSQRTPS(a, b) rsqrtps P_ARG2(a, b)
1663 :     #define RSQRTSS(a, b) rsqrtss P_ARG2(a, b)
1664 :     #define SHUFPS(a, b, c) shufps P_ARG3(a, b, c)
1665 :     #define SQRTPS(a, b) sqrtps P_ARG2(a, b)
1666 :     #define SQRTSS(a, b) sqrtss P_ARG2(a, b)
1667 :     #define STMXCSR(a) stmxcsr P_ARG1(a)
1668 :     #define SUBPS(a, b) subps P_ARG2(a, b)
1669 :     #define UCOMISS(a, b) ucomiss P_ARG2(a, b)
1670 :     #define UNPCKHPS(a, b) unpckhps P_ARG2(a, b)
1671 :     #define UNPCKLPS(a, b) unpcklps P_ARG2(a, b)
1672 :     #define XORPS(a, b) xorps P_ARG2(a, b)
1673 :    
1674 :     #define PREFETCHNTA(a) prefetchnta P_ARG1(a)
1675 :     #define PREFETCHT0(a) prefetcht0 P_ARG1(a)
1676 :     #define PREFETCHT1(a) prefetcht1 P_ARG1(a)
1677 :     #define PREFETCHT2(a) prefetcht2 P_ARG1(a)
1678 :     #define SFENCE sfence
1679 :    
1680 :     /* Added by BrianP for FreeBSD (per David Dawes) */
1681 :     #if !defined(NASM_ASSEMBLER) && !defined(MASM_ASSEMBLER) && !defined(__bsdi__)
1682 :     #define LLBL(a) CONCAT(.L,a)
1683 :     #else
1684 :     #define LLBL(a) a
1685 :     #endif
1686 :    
1687 :    
1688 : monnier 437 #endif /* __ASSYNTAX_H__ */

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0