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