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