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__ */ |