| 1 | /* $XFree86: xc/programs/Xserver/hw/xfree86/os-support/assyntax.h,v 3.12 1999/12/27 00:39:46 robin Exp $ */
|
|---|
| 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 SOFTWARE,
|
|---|
| 19 | * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
|
|---|
| 20 | * EVENT SHALL The Vrije Universiteit BE LIABLE FOR ANY SPECIAL, INDIRECT OR
|
|---|
| 21 | * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
|---|
| 22 | * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|---|
| 23 | * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|---|
| 24 | * PERFORMANCE OF THIS SOFTWARE.
|
|---|
| 25 | */
|
|---|
| 26 | /* $XConsortium: assyntax.h /main/5 1996/02/21 17:50:49 kaleb $ */
|
|---|
| 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): default
|
|---|
| 46 | * (b) GNU Assembler gas: define USE_GAS or GNU_ASSEMBLER
|
|---|
| 47 | * (c) Amsterdam Compiler kit: define ACK_ASSEMBLER
|
|---|
| 48 | *
|
|---|
| 49 | * The following naming conventions have been used to identify the various
|
|---|
| 50 | * data types:
|
|---|
| 51 | * _SR = segment register version
|
|---|
| 52 | * Integer:
|
|---|
| 53 | * _Q = quadword = 64 bits
|
|---|
| 54 | * _L = long = 32 bits
|
|---|
| 55 | * _W = short = 16 bits
|
|---|
| 56 | * _B = byte = 8 bits
|
|---|
| 57 | * Floating-point:
|
|---|
| 58 | * _X = m80real = 80 bits
|
|---|
| 59 | * _D = double = 64 bits
|
|---|
| 60 | * _S = single = 32 bits
|
|---|
| 61 | *
|
|---|
| 62 | * Author: Gregory J. Sharp, Sept 1992
|
|---|
| 63 | * Vrije Universiteit, Amsterdam, The Netherlands
|
|---|
| 64 | */
|
|---|
| 65 |
|
|---|
| 66 | #if defined(USE_GAS) && !defined(GNU_ASSEMBLER)
|
|---|
| 67 | #define GNU_ASSEMBLER
|
|---|
| 68 | #endif
|
|---|
| 69 |
|
|---|
| 70 | #if (defined(__STDC__) && !defined(UNIXCPP)) || (defined (sun) && defined (i386) && defined (SVR4) && defined (__STDC__) && !defined (__GNUC__))
|
|---|
| 71 | #define CONCAT(x, y) x ## y
|
|---|
| 72 | #else
|
|---|
| 73 | #define CONCAT(x, y) x/**/y
|
|---|
| 74 | #endif
|
|---|
| 75 |
|
|---|
| 76 | #ifdef ACK_ASSEMBLER
|
|---|
| 77 |
|
|---|
| 78 | /* Assume we write code for 32-bit protected mode! */
|
|---|
| 79 |
|
|---|
| 80 | /* Redefine register names for GAS & AT&T assemblers */
|
|---|
| 81 | #define AL al
|
|---|
| 82 | #define AH ah
|
|---|
| 83 | #define AX ax
|
|---|
| 84 | #define EAX ax
|
|---|
| 85 | #define BL bl
|
|---|
| 86 | #define BH bh
|
|---|
| 87 | #define BX bx
|
|---|
| 88 | #define EBX bx
|
|---|
| 89 | #define CL cl
|
|---|
| 90 | #define CH ch
|
|---|
| 91 | #define CX cx
|
|---|
| 92 | #define ECX cx
|
|---|
| 93 | #define DL dl
|
|---|
| 94 | #define DH dh
|
|---|
| 95 | #define DX dx
|
|---|
| 96 | #define EDX dx
|
|---|
| 97 | #define BP bp
|
|---|
| 98 | #define EBP bp
|
|---|
| 99 | #define SI si
|
|---|
| 100 | #define ESI si
|
|---|
| 101 | #define DI di
|
|---|
| 102 | #define EDI di
|
|---|
| 103 | #define SP sp
|
|---|
| 104 | #define ESP sp
|
|---|
| 105 | #define CS cs
|
|---|
| 106 | #define SS ss
|
|---|
| 107 | #define DS ds
|
|---|
| 108 | #define ES es
|
|---|
| 109 | #define FS fs
|
|---|
| 110 | #define GS gs
|
|---|
| 111 | /* Control Registers */
|
|---|
| 112 | #define CR0 cr0
|
|---|
| 113 | #define CR1 cr1
|
|---|
| 114 | #define CR2 cr2
|
|---|
| 115 | #define CR3 cr3
|
|---|
| 116 | /* Debug Registers */
|
|---|
| 117 | #define DR0 dr0
|
|---|
| 118 | #define DR1 dr1
|
|---|
| 119 | #define DR2 dr2
|
|---|
| 120 | #define DR3 dr3
|
|---|
| 121 | #define DR4 dr4
|
|---|
| 122 | #define DR5 dr5
|
|---|
| 123 | #define DR6 dr6
|
|---|
| 124 | #define DR7 dr7
|
|---|
| 125 | /* Floating-point Stack */
|
|---|
| 126 | #define ST st
|
|---|
| 127 |
|
|---|
| 128 | #define AS_BEGIN .sect .text; .sect .rom; .sect .data; .sect .bss; .sect .text
|
|---|
| 129 |
|
|---|
| 130 |
|
|---|
| 131 | #define _WTOG o16 /* word toggle for _W instructions */
|
|---|
| 132 | #define _LTOG /* long toggle for _L instructions */
|
|---|
| 133 | #define ADDR_TOGGLE a16
|
|---|
| 134 | #define OPSZ_TOGGLE o16
|
|---|
| 135 | #define USE16 .use16
|
|---|
| 136 | #define USE32 .use32
|
|---|
| 137 |
|
|---|
| 138 | #define CHOICE(a,b,c) c
|
|---|
| 139 |
|
|---|
| 140 | #else /* AT&T or GAS */
|
|---|
| 141 |
|
|---|
| 142 | /* Redefine register names for GAS & AT&T assemblers */
|
|---|
| 143 | #define AL %al
|
|---|
| 144 | #define AH %ah
|
|---|
| 145 | #define AX %ax
|
|---|
| 146 | #define EAX %eax
|
|---|
| 147 | #define BL %bl
|
|---|
| 148 | #define BH %bh
|
|---|
| 149 | #define BX %bx
|
|---|
| 150 | #define EBX %ebx
|
|---|
| 151 | #define CL %cl
|
|---|
| 152 | #define CH %ch
|
|---|
| 153 | #define CX %cx
|
|---|
| 154 | #define ECX %ecx
|
|---|
| 155 | #define DL %dl
|
|---|
| 156 | #define DH %dh
|
|---|
| 157 | #define DX %dx
|
|---|
| 158 | #define EDX %edx
|
|---|
| 159 | #define BP %bp
|
|---|
| 160 | #define EBP %ebp
|
|---|
| 161 | #define SI %si
|
|---|
| 162 | #define ESI %esi
|
|---|
| 163 | #define DI %di
|
|---|
| 164 | #define EDI %edi
|
|---|
| 165 | #define SP %sp
|
|---|
| 166 | #define ESP %esp
|
|---|
| 167 | #define CS %cs
|
|---|
| 168 | #define SS %ss
|
|---|
| 169 | #define DS %ds
|
|---|
| 170 | #define ES %es
|
|---|
| 171 | #define FS %fs
|
|---|
| 172 | #define GS %gs
|
|---|
| 173 | /* Control Registers */
|
|---|
| 174 | #define CR0 %cr0
|
|---|
| 175 | #define CR1 %cr1
|
|---|
| 176 | #define CR2 %cr2
|
|---|
| 177 | #define CR3 %cr3
|
|---|
| 178 | /* Debug Registers */
|
|---|
| 179 | #define DR0 %db0
|
|---|
| 180 | #define DR1 %db1
|
|---|
| 181 | #define DR2 %db2
|
|---|
| 182 | #define DR3 %db3
|
|---|
| 183 | #define DR4 %db4
|
|---|
| 184 | #define DR5 %db5
|
|---|
| 185 | #define DR6 %db6
|
|---|
| 186 | #define DR7 %db7
|
|---|
| 187 | /* Floating-point Stack */
|
|---|
| 188 | #define ST %st
|
|---|
| 189 |
|
|---|
| 190 | #define AS_BEGIN
|
|---|
| 191 | #define USE16
|
|---|
| 192 | #define USE32
|
|---|
| 193 |
|
|---|
| 194 | #ifdef GNU_ASSEMBLER
|
|---|
| 195 |
|
|---|
| 196 | #define ADDR_TOGGLE aword
|
|---|
| 197 | #define OPSZ_TOGGLE word
|
|---|
| 198 |
|
|---|
| 199 | #define CHOICE(a,b,c) b
|
|---|
| 200 |
|
|---|
| 201 | #else
|
|---|
| 202 | /*
|
|---|
| 203 | * AT&T ASSEMBLER SYNTAX
|
|---|
| 204 | * *********************
|
|---|
| 205 | */
|
|---|
| 206 | #define CHOICE(a,b,c) a
|
|---|
| 207 |
|
|---|
| 208 | #define ADDR_TOGGLE addr16
|
|---|
| 209 | #define OPSZ_TOGGLE data16
|
|---|
| 210 |
|
|---|
| 211 | #endif /* GNU_ASSEMBLER */
|
|---|
| 212 | #endif /* ACK_ASSEMBLER */
|
|---|
| 213 |
|
|---|
| 214 |
|
|---|
| 215 | #if defined(__QNX__) || defined(Lynx) || (defined(SYSV) || defined(SVR4)) && !defined(ACK_ASSEMBLER) || defined(__ELF__) || defined(__GNU__)
|
|---|
| 216 | #define GLNAME(a) a
|
|---|
| 217 | #else
|
|---|
| 218 | #define GLNAME(a) CONCAT(_,a)
|
|---|
| 219 | #endif
|
|---|
| 220 |
|
|---|
| 221 |
|
|---|
| 222 | /****************************************/
|
|---|
| 223 | /* */
|
|---|
| 224 | /* Select the various choices */
|
|---|
| 225 | /* */
|
|---|
| 226 | /****************************************/
|
|---|
| 227 |
|
|---|
| 228 |
|
|---|
| 229 | /* Redefine assembler directives */
|
|---|
| 230 | /*********************************/
|
|---|
| 231 | #define GLOBL CHOICE(.globl, .globl, .extern)
|
|---|
| 232 | #define ALIGNTEXT4 CHOICE(.align 4, .align ARG2(2,0x90), .align 4)
|
|---|
| 233 | #define ALIGNTEXT2 CHOICE(.align 2, .align ARG2(1,0x90), .align 2)
|
|---|
| 234 | /* ALIGNTEXT4ifNOP is the same as ALIGNTEXT4, but only if the space is
|
|---|
| 235 | * guaranteed to be filled with NOPs. Otherwise it does nothing.
|
|---|
| 236 | */
|
|---|
| 237 | #define ALIGNTEXT4ifNOP CHOICE(.align 4, .align ARG2(2,0x90), /*can't do it*/)
|
|---|
| 238 | #define ALIGNDATA4 CHOICE(.align 4, .align ARG2(2,0x0), .align 4)
|
|---|
| 239 | #define ALIGNDATA2 CHOICE(.align 2, .align ARG2(1,0x0), .align 2)
|
|---|
| 240 | #define FILE(s) CHOICE(.file s, .file s, .file s)
|
|---|
| 241 | #define STRING(s) CHOICE(.string s, .asciz s, .asciz s)
|
|---|
| 242 | #define D_LONG CHOICE(.long, .long, .data4)
|
|---|
| 243 | #define D_WORD CHOICE(.value, .short, .data2)
|
|---|
| 244 | #define D_BYTE CHOICE(.byte, .byte, .data1)
|
|---|
| 245 | #define SPACE CHOICE(.comm, .space, .space)
|
|---|
| 246 | #define COMM CHOICE(.comm, .comm, .comm)
|
|---|
| 247 | #define SEG_DATA CHOICE(.data, .data, .sect .data)
|
|---|
| 248 | #define SEG_TEXT CHOICE(.text, .text, .sect .text)
|
|---|
| 249 | #define SEG_BSS CHOICE(.bss, .bss, .sect .bss)
|
|---|
| 250 |
|
|---|
| 251 | #ifdef GNU_ASSEMBLER
|
|---|
| 252 | #define D_SPACE(n) . = . + n
|
|---|
| 253 | #else
|
|---|
| 254 | #define D_SPACE(n) .space n
|
|---|
| 255 | #endif
|
|---|
| 256 |
|
|---|
| 257 | /* Addressing Modes */
|
|---|
| 258 | /* Immediate Mode */
|
|---|
| 259 | #define ADDR(a) CHOICE(CONCAT($,a), CONCAT($,a), a)
|
|---|
| 260 | #define CONST(a) CHOICE(CONCAT($,a), CONCAT($,a), a)
|
|---|
| 261 |
|
|---|
| 262 | /* Indirect Mode */
|
|---|
| 263 | #define CONTENT(a) CHOICE(a, a, (a)) /* take contents of variable */
|
|---|
| 264 | #define REGIND(a) CHOICE((a), (a), (a)) /* Register a indirect */
|
|---|
| 265 | /* Register b indirect plus displacement a */
|
|---|
| 266 | #define REGOFF(a, b) CHOICE(a(b), a(b), a(b))
|
|---|
| 267 | /* Reg indirect Base + Index + Displacement - this is mainly for 16-bit mode
|
|---|
| 268 | * which has no scaling
|
|---|
| 269 | */
|
|---|
| 270 | #define REGBID(b,i,d) CHOICE(d(b,i), d(b,i), d(b)(i))
|
|---|
| 271 | /* Reg indirect Base + (Index * Scale) + Displacement */
|
|---|
| 272 | #define REGBISD(b,i,s,d) CHOICE(d(b,i,s), d(b,i,s), d(b)(i*s))
|
|---|
| 273 | /* Displaced Scaled Index: */
|
|---|
| 274 | #define REGDIS(d,i,s) CHOICE(d(,i,s), d(,i,s), d(i * s))
|
|---|
| 275 | /* Indexed Base: */
|
|---|
| 276 | #define REGBI(b,i) CHOICE((b,i), (b,i), (b)(i))
|
|---|
| 277 | /* Displaced Base: */
|
|---|
| 278 | #define REGDB(d,b) CHOICE(d(b), d(b), d(b))
|
|---|
| 279 | /* Variable indirect: */
|
|---|
| 280 | #define VARINDIRECT(var) CHOICE(*var, *var, (var))
|
|---|
| 281 | /* Use register contents as jump/call target: */
|
|---|
| 282 | #define CODEPTR(reg) CHOICE(*reg, *reg, reg)
|
|---|
| 283 |
|
|---|
| 284 | /* For expressions requiring bracketing
|
|---|
| 285 | * eg. (CRT0_PM | CRT_EM)
|
|---|
| 286 | */
|
|---|
| 287 |
|
|---|
| 288 | #define EXPR(a) CHOICE([a], (a), [a])
|
|---|
| 289 | #define ENOT(a) CHOICE(0!a, ~a, ~a)
|
|---|
| 290 | #define EMUL(a,b) CHOICE(a\*b, a*b, a*b)
|
|---|
| 291 | #define EDIV(a,b) CHOICE(a\/b, a/b, a/b)
|
|---|
| 292 |
|
|---|
| 293 | /*
|
|---|
| 294 | * We have to beat the problem of commas within arguments to choice.
|
|---|
| 295 | * eg. choice (add a,b, add b,a) will get argument mismatch. Luckily ANSI
|
|---|
| 296 | * and other known cpp definitions evaluate arguments before substitution
|
|---|
| 297 | * so the following works.
|
|---|
| 298 | */
|
|---|
| 299 | #define ARG2(a, b) a,b
|
|---|
| 300 | #define ARG3(a,b,c) a,b,c
|
|---|
| 301 |
|
|---|
| 302 | /* Redefine assembler commands */
|
|---|
| 303 | #define AAA CHOICE(aaa, aaa, aaa)
|
|---|
| 304 | #define AAD CHOICE(aad, aad, aad)
|
|---|
| 305 | #define AAM CHOICE(aam, aam, aam)
|
|---|
| 306 | #define AAS CHOICE(aas, aas, aas)
|
|---|
| 307 | #define ADC_L(a, b) CHOICE(adcl ARG2(a,b), adcl ARG2(a,b), _LTOG adc ARG2(b,a))
|
|---|
| 308 | #define ADC_W(a, b) CHOICE(adcw ARG2(a,b), adcw ARG2(a,b), _WTOG adc ARG2(b,a))
|
|---|
| 309 | #define ADC_B(a, b) CHOICE(adcb ARG2(a,b), adcb ARG2(a,b), adcb ARG2(b,a))
|
|---|
| 310 | #define ADD_L(a, b) CHOICE(addl ARG2(a,b), addl ARG2(a,b), _LTOG add ARG2(b,a))
|
|---|
| 311 | #define ADD_W(a, b) CHOICE(addw ARG2(a,b), addw ARG2(a,b), _WTOG add ARG2(b,a))
|
|---|
| 312 | #define ADD_B(a, b) CHOICE(addb ARG2(a,b), addb ARG2(a,b), addb ARG2(b,a))
|
|---|
| 313 | #define AND_L(a, b) CHOICE(andl ARG2(a,b), andl ARG2(a,b), _LTOG and ARG2(b,a))
|
|---|
| 314 | #define AND_W(a, b) CHOICE(andw ARG2(a,b), andw ARG2(a,b), _WTOG and ARG2(b,a))
|
|---|
| 315 | #define AND_B(a, b) CHOICE(andb ARG2(a,b), andb ARG2(a,b), andb ARG2(b,a))
|
|---|
| 316 | #define ARPL(a,b) CHOICE(arpl ARG2(a,b), arpl ARG2(a,b), arpl ARG2(b,a))
|
|---|
| 317 | #define BOUND_L(a, b) CHOICE(boundl ARG2(a,b), boundl ARG2(b,a), _LTOG bound ARG2(b,a))
|
|---|
| 318 | #define BOUND_W(a, b) CHOICE(boundw ARG2(a,b), boundw ARG2(b,a), _WTOG bound ARG2(b,a))
|
|---|
| 319 | #define BSF_L(a, b) CHOICE(bsfl ARG2(a,b), bsfl ARG2(a,b), _LTOG bsf ARG2(b,a))
|
|---|
| 320 | #define BSF_W(a, b) CHOICE(bsfw ARG2(a,b), bsfw ARG2(a,b), _WTOG bsf ARG2(b,a))
|
|---|
| 321 | #define BSR_L(a, b) CHOICE(bsrl ARG2(a,b), bsrl ARG2(a,b), _LTOG bsr ARG2(b,a))
|
|---|
| 322 | #define BSR_W(a, b) CHOICE(bsrw ARG2(a,b), bsrw ARG2(a,b), _WTOG bsr ARG2(b,a))
|
|---|
| 323 | #define BT_L(a, b) CHOICE(btl ARG2(a,b), btl ARG2(a,b), _LTOG bt ARG2(b,a))
|
|---|
| 324 | #define BT_W(a, b) CHOICE(btw ARG2(a,b), btw ARG2(a,b), _WTOG bt ARG2(b,a))
|
|---|
| 325 | #define BTC_L(a, b) CHOICE(btcl ARG2(a,b), btcl ARG2(a,b), _LTOG btc ARG2(b,a))
|
|---|
| 326 | #define BTC_W(a, b) CHOICE(btcw ARG2(a,b), btcw ARG2(a,b), _WTOG btc ARG2(b,a))
|
|---|
| 327 | #define BTR_L(a, b) CHOICE(btrl ARG2(a,b), btrl ARG2(a,b), _LTOG btr ARG2(b,a))
|
|---|
| 328 | #define BTR_W(a, b) CHOICE(btrw ARG2(a,b), btrw ARG2(a,b), _WTOG btr ARG2(b,a))
|
|---|
| 329 | #define BTS_L(a, b) CHOICE(btsl ARG2(a,b), btsl ARG2(a,b), _LTOG bts ARG2(b,a))
|
|---|
| 330 | #define BTS_W(a, b) CHOICE(btsw ARG2(a,b), btsw ARG2(a,b), _WTOG bts ARG2(b,a))
|
|---|
| 331 | #define CALL(a) CHOICE(call a, call a, call a)
|
|---|
| 332 | #define CALLF(s,a) CHOICE(lcall ARG2(s,a), lcall ARG2(s,a), callf s:a)
|
|---|
| 333 | #define CBW CHOICE(cbtw, cbw, cbw)
|
|---|
| 334 | #define CWDE CHOICE(cwtd, cwde, cwde)
|
|---|
| 335 | #define CLC CHOICE(clc, clc, clc)
|
|---|
| 336 | #define CLD CHOICE(cld, cld, cld)
|
|---|
| 337 | #define CLI CHOICE(cli, cli, cli)
|
|---|
| 338 | #define CLTS CHOICE(clts, clts, clts)
|
|---|
| 339 | #define CMC CHOICE(cmc, cmc, cmc)
|
|---|
| 340 | #define CMP_L(a, b) CHOICE(cmpl ARG2(a,b), cmpl ARG2(a,b), _LTOG cmp ARG2(b,a))
|
|---|
| 341 | #define CMP_W(a, b) CHOICE(cmpw ARG2(a,b), cmpw ARG2(a,b), _WTOG cmp ARG2(b,a))
|
|---|
| 342 | #define CMP_B(a, b) CHOICE(cmpb ARG2(a,b), cmpb ARG2(a,b), cmpb ARG2(b,a))
|
|---|
| 343 | #define CMPS_L CHOICE(cmpsl, cmpsl, _LTOG cmps)
|
|---|
| 344 | #define CMPS_W CHOICE(cmpsw, cmpsw, _WTOG cmps)
|
|---|
| 345 | #define CMPS_B CHOICE(cmpsb, cmpsb, cmpsb)
|
|---|
| 346 | #define CWD CHOICE(cwtl, cwd, cwd)
|
|---|
| 347 | #define CDQ CHOICE(cltd, cdq, cdq)
|
|---|
| 348 | #define DAA CHOICE(daa, daa, daa)
|
|---|
| 349 | #define DAS CHOICE(das, das, das)
|
|---|
| 350 | #define DEC_L(a) CHOICE(decl a, decl a, _LTOG dec a)
|
|---|
| 351 | #define DEC_W(a) CHOICE(decw a, decw a, _WTOG dec a)
|
|---|
| 352 | #define DEC_B(a) CHOICE(decb a, decb a, decb a)
|
|---|
| 353 | #define DIV_L(a) CHOICE(divl a, divl a, div a)
|
|---|
| 354 | #define DIV_W(a) CHOICE(divw a, divw a, div a)
|
|---|
| 355 | #define DIV_B(a) CHOICE(divb a, divb a, divb a)
|
|---|
| 356 | #define ENTER(a,b) CHOICE(enter ARG2(a,b), enter ARG2(a,b), enter ARG2(b,a))
|
|---|
| 357 | #define HLT CHOICE(hlt, hlt, hlt)
|
|---|
| 358 | #define IDIV_L(a) CHOICE(idivl a, idivl a, _LTOG idiv a)
|
|---|
| 359 | #define IDIV_W(a) CHOICE(idivw a, idivw a, _WTOG idiv a)
|
|---|
| 360 | #define IDIV_B(a) CHOICE(idivb a, idivb a, idivb a)
|
|---|
| 361 | /* More forms than this for imul!! */
|
|---|
| 362 | #define IMUL_L(a, b) CHOICE(imull ARG2(a,b), imull ARG2(a,b), _LTOG imul ARG2(b,a))
|
|---|
| 363 | #define IMUL_W(a, b) CHOICE(imulw ARG2(a,b), imulw ARG2(a,b), _WTOG imul ARG2(b,a))
|
|---|
| 364 | #define IMUL_B(a) CHOICE(imulb a, imulb a, imulb a)
|
|---|
| 365 | #define IN_L CHOICE(inl (DX), inl ARG2(DX,EAX), _LTOG in DX)
|
|---|
| 366 | #define IN_W CHOICE(inw (DX), inw ARG2(DX,AX), _WTOG in DX)
|
|---|
| 367 | #define IN_B CHOICE(inb (DX), inb ARG2(DX,AL), inb DX)
|
|---|
| 368 | /* Please AS code writer: use the following ONLY, if you refer to ports<256
|
|---|
| 369 | * directly, but not in IN1_W(DX), for instance, even if IN1_ looks nicer
|
|---|
| 370 | */
|
|---|
| 371 | #if defined (sun)
|
|---|
| 372 | #define IN1_L(a) CHOICE(inl (a), inl ARG2(a,EAX), _LTOG in a)
|
|---|
| 373 | #define IN1_W(a) CHOICE(inw (a), inw ARG2(a,AX), _WTOG in a)
|
|---|
| 374 | #define IN1_B(a) CHOICE(inb (a), inb ARG2(a,AL), inb a)
|
|---|
| 375 | #else
|
|---|
| 376 | #define IN1_L(a) CHOICE(inl a, inl ARG2(a,EAX), _LTOG in a)
|
|---|
| 377 | #define IN1_W(a) CHOICE(inw a, inw ARG2(a,AX), _WTOG in a)
|
|---|
| 378 | #define IN1_B(a) CHOICE(inb a, inb ARG2(a,AL), inb a)
|
|---|
| 379 | #endif
|
|---|
| 380 | #define INC_L(a) CHOICE(incl a, incl a, _LTOG inc a)
|
|---|
| 381 | #define INC_W(a) CHOICE(incw a, incw a, _WTOG inc a)
|
|---|
| 382 | #define INC_B(a) CHOICE(incb a, incb a, incb a)
|
|---|
| 383 | #define INS_L CHOICE(insl, insl, _LTOG ins)
|
|---|
| 384 | #define INS_W CHOICE(insw, insw, _WTOG ins)
|
|---|
| 385 | #define INS_B CHOICE(insb, insb, insb)
|
|---|
| 386 | #define INT(a) CHOICE(int a, int a, int a)
|
|---|
| 387 | #define INT3 CHOICE(int CONST(3), int3, int CONST(3))
|
|---|
| 388 | #define INTO CHOICE(into, into, into)
|
|---|
| 389 | #define IRET CHOICE(iret, iret, iret)
|
|---|
| 390 | #define IRETD CHOICE(iret, iret, iretd)
|
|---|
| 391 | #define JA(a) CHOICE(ja a, ja a, ja a)
|
|---|
| 392 | #define JAE(a) CHOICE(jae a, jae a, jae a)
|
|---|
| 393 | #define JB(a) CHOICE(jb a, jb a, jb a)
|
|---|
| 394 | #define JBE(a) CHOICE(jbe a, jbe a, jbe a)
|
|---|
| 395 | #define JC(a) CHOICE(jc a, jc a, jc a)
|
|---|
| 396 | #define JE(a) CHOICE(je a, je a, je a)
|
|---|
| 397 | #define JG(a) CHOICE(jg a, jg a, jg a)
|
|---|
| 398 | #define JGE(a) CHOICE(jge a, jge a, jge a)
|
|---|
| 399 | #define JL(a) CHOICE(jl a, jl a, jl a)
|
|---|
| 400 | #define JLE(a) CHOICE(jle a, jle a, jle a)
|
|---|
| 401 | #define JNA(a) CHOICE(jna a, jna a, jna a)
|
|---|
| 402 | #define JNAE(a) CHOICE(jnae a, jnae a, jnae a)
|
|---|
| 403 | #define JNB(a) CHOICE(jnb a, jnb a, jnb a)
|
|---|
| 404 | #define JNBE(a) CHOICE(jnbe a, jnbe a, jnbe a)
|
|---|
| 405 | #define JNC(a) CHOICE(jnc a, jnc a, jnc a)
|
|---|
| 406 | #define JNE(a) CHOICE(jne a, jne a, jne a)
|
|---|
| 407 | #define JNG(a) CHOICE(jng a, jng a, jng a)
|
|---|
| 408 | #define JNGE(a) CHOICE(jnge a, jnge a, jnge a)
|
|---|
| 409 | #define JNL(a) CHOICE(jnl a, jnl a, jnl a)
|
|---|
| 410 | #define JNLE(a) CHOICE(jnle a, jnle a, jnle a)
|
|---|
| 411 | #define JNO(a) CHOICE(jno a, jno a, jno a)
|
|---|
| 412 | #define JNP(a) CHOICE(jnp a, jnp a, jnp a)
|
|---|
| 413 | #define JNS(a) CHOICE(jns a, jns a, jns a)
|
|---|
| 414 | #define JNZ(a) CHOICE(jnz a, jnz a, jnz a)
|
|---|
| 415 | #define JO(a) CHOICE(jo a, jo a, jo a)
|
|---|
| 416 | #define JP(a) CHOICE(jp a, jp a, jp a)
|
|---|
| 417 | #define JPE(a) CHOICE(jpe a, jpe a, jpe a)
|
|---|
| 418 | #define JPO(a) CHOICE(jpo a, jpo a, jpo a)
|
|---|
| 419 | #define JS(a) CHOICE(js a, js a, js a)
|
|---|
| 420 | #define JZ(a) CHOICE(jz a, jz a, jz a)
|
|---|
| 421 | #define JMP(a) CHOICE(jmp a, jmp a, jmp a)
|
|---|
| 422 | #define JMPF(s,a) CHOICE(ljmp ARG2(s,a), ljmp ARG2(s,a), jmpf s:a)
|
|---|
| 423 | #define LAHF CHOICE(lahf, lahf, lahf)
|
|---|
| 424 | #if !defined(_REAL_MODE) && !defined(_V86_MODE)
|
|---|
| 425 | #define LAR(a, b) CHOICE(lar ARG2(a, b), lar ARG2(a, b), lar ARG2(b, a))
|
|---|
| 426 | #endif
|
|---|
| 427 | #define LEA_L(a, b) CHOICE(leal ARG2(a,b), leal ARG2(a,b), _LTOG lea ARG2(b,a))
|
|---|
| 428 | #define LEA_W(a, b) CHOICE(leaw ARG2(a,b), leaw ARG2(a,b), _WTOG lea ARG2(b,a))
|
|---|
| 429 | #define LEAVE CHOICE(leave, leave, leave)
|
|---|
| 430 | #define LGDT(a) CHOICE(lgdt a, lgdt a, lgdt a)
|
|---|
| 431 | #define LIDT(a) CHOICE(lidt a, lidt a, lidt a)
|
|---|
| 432 | #define LDS(a, b) CHOICE(ldsl ARG2(a,b), lds ARG2(a,b), lds ARG2(b,a))
|
|---|
| 433 | #define LES(a, b) CHOICE(lesl ARG2(a,b), les ARG2(a,b), les ARG2(b,a))
|
|---|
| 434 | #define LFS(a, b) CHOICE(lfsl ARG2(a,b), lfs ARG2(a,b), lfs ARG2(b,a))
|
|---|
| 435 | #define LGS(a, b) CHOICE(lgsl ARG2(a,b), lgs ARG2(a,b), lgs ARG2(b,a))
|
|---|
| 436 | #define LSS(a, b) CHOICE(lssl ARG2(a,b), lss ARG2(a,b), lss ARG2(b,a))
|
|---|
| 437 | #define LLDT(a) CHOICE(lldt a, lldt a, lldt a)
|
|---|
| 438 | #define LMSW(a) CHOICE(lmsw a, lmsw a, lmsw a)
|
|---|
| 439 | #define LOCK CHOICE(lock, lock, lock)
|
|---|
| 440 | #define LODS_L CHOICE(lodsl, lodsl, _LTOG lods)
|
|---|
| 441 | #define LODS_W CHOICE(lodsw, lodsw, _WTOG lods)
|
|---|
| 442 | #define LODS_B CHOICE(lodsb, lodsb, lodsb)
|
|---|
| 443 | #define LOOP(a) CHOICE(loop a, loop a, loop a)
|
|---|
| 444 | #define LOOPE(a) CHOICE(loope a, loope a, loope a)
|
|---|
| 445 | #define LOOPZ(a) CHOICE(loopz a, loopz a, loopz a)
|
|---|
| 446 | #define LOOPNE(a) CHOICE(loopne a, loopne a, loopne a)
|
|---|
| 447 | #define LOOPNZ(a) CHOICE(loopnz a, loopnz a, loopnz a)
|
|---|
| 448 | #if !defined(_REAL_MODE) && !defined(_V86_MODE)
|
|---|
| 449 | #define LSL(a, b) CHOICE(lsl ARG2(a,b), lsl ARG2(a,b), lsl ARG2(b,a))
|
|---|
| 450 | #endif
|
|---|
| 451 | #define LTR(a) CHOICE(ltr a, ltr a, ltr a)
|
|---|
| 452 | #define MOV_SR(a, b) CHOICE(movw ARG2(a,b), mov ARG2(a,b), mov ARG2(b,a))
|
|---|
| 453 | #define MOV_L(a, b) CHOICE(movl ARG2(a,b), movl ARG2(a,b), _LTOG mov ARG2(b,a))
|
|---|
| 454 | #define MOV_W(a, b) CHOICE(movw ARG2(a,b), movw ARG2(a,b), _WTOG mov ARG2(b,a))
|
|---|
| 455 | #define MOV_B(a, b) CHOICE(movb ARG2(a,b), movb ARG2(a,b), movb ARG2(b,a))
|
|---|
| 456 | #define MOVS_L CHOICE(movsl, movsl, _LTOG movs)
|
|---|
| 457 | #define MOVS_W CHOICE(movsw, movsw, _WTOG movs)
|
|---|
| 458 | #define MOVS_B CHOICE(movsb, movsb, movsb)
|
|---|
| 459 | #define MOVSX_BL(a, b) CHOICE(movsbl ARG2(a,b), movsbl ARG2(a,b), movsx ARG2(b,a))
|
|---|
| 460 | #define MOVSX_BW(a, b) CHOICE(movsbw ARG2(a,b), movsbw ARG2(a,b), movsx ARG2(b,a))
|
|---|
| 461 | #define MOVSX_WL(a, b) CHOICE(movswl ARG2(a,b), movswl ARG2(a,b), movsx ARG2(b,a))
|
|---|
| 462 | #define MOVZX_BL(a, b) CHOICE(movzbl ARG2(a,b), movzbl ARG2(a,b), movzx ARG2(b,a))
|
|---|
| 463 | #define MOVZX_BW(a, b) CHOICE(movzbw ARG2(a,b), movzbw ARG2(a,b), movzx ARG2(b,a))
|
|---|
| 464 | #define MOVZX_WL(a, b) CHOICE(movzwl ARG2(a,b), movzwl ARG2(a,b), movzx ARG2(b,a))
|
|---|
| 465 | #define MUL_L(a) CHOICE(mull a, mull a, _LTOG mul a)
|
|---|
| 466 | #define MUL_W(a) CHOICE(mulw a, mulw a, _WTOG mul a)
|
|---|
| 467 | #define MUL_B(a) CHOICE(mulb a, mulb a, mulb a)
|
|---|
| 468 | #define NEG_L(a) CHOICE(negl a, negl a, _LTOG neg a)
|
|---|
| 469 | #define NEG_W(a) CHOICE(negw a, negw a, _WTOG neg a)
|
|---|
| 470 | #define NEG_B(a) CHOICE(negb a, negb a, negb a)
|
|---|
| 471 | #define NOP CHOICE(nop, nop, nop)
|
|---|
| 472 | #define NOT_L(a) CHOICE(notl a, notl a, _LTOG not a)
|
|---|
| 473 | #define NOT_W(a) CHOICE(notw a, notw a, _WTOG not a)
|
|---|
| 474 | #define NOT_B(a) CHOICE(notb a, notb a, notb a)
|
|---|
| 475 | #define OR_L(a,b) CHOICE(orl ARG2(a,b), orl ARG2(a,b), _LTOG or ARG2(b,a))
|
|---|
| 476 | #define OR_W(a,b) CHOICE(orw ARG2(a,b), orw ARG2(a,b), _WTOG or ARG2(b,a))
|
|---|
| 477 | #define OR_B(a,b) CHOICE(orb ARG2(a,b), orb ARG2(a,b), orb ARG2(b,a))
|
|---|
| 478 | #define OUT_L CHOICE(outl (DX), outl ARG2(EAX,DX), _LTOG out DX)
|
|---|
| 479 | #define OUT_W CHOICE(outw (DX), outw ARG2(AX,DX), _WTOG out DX)
|
|---|
| 480 | #define OUT_B CHOICE(outb (DX), outb ARG2(AL,DX), outb DX)
|
|---|
| 481 | /* Please AS code writer: use the following ONLY, if you refer to ports<256
|
|---|
| 482 | * directly, but not in OUT1_W(DX), for instance, even if OUT1_ looks nicer
|
|---|
| 483 | */
|
|---|
| 484 | #define OUT1_L(a) CHOICE(outl (a), outl ARG2(EAX,a), _LTOG out a)
|
|---|
| 485 | #define OUT1_W(a) CHOICE(outw (a), outw ARG2(AX,a), _WTOG out a)
|
|---|
| 486 | #define OUT1_B(a) CHOICE(outb (a), outb ARG2(AL,a), outb a)
|
|---|
| 487 | #define OUTS_L CHOICE(outsl, outsl, _LTOG outs)
|
|---|
| 488 | #define OUTS_W CHOICE(outsw, outsw, _WTOG outs)
|
|---|
| 489 | #define OUTS_B CHOICE(outsb, outsb, outsb)
|
|---|
| 490 | #define POP_SR(a) CHOICE(pop a, pop a, pop a)
|
|---|
| 491 | #define POP_L(a) CHOICE(popl a, popl a, _LTOG pop a)
|
|---|
| 492 | #define POP_W(a) CHOICE(popw a, popw a, _WTOG pop a)
|
|---|
| 493 | #define POPA_L CHOICE(popal, popal, _LTOG popa)
|
|---|
| 494 | #define POPA_W CHOICE(popaw, popaw, _WTOG popa)
|
|---|
| 495 | #define POPF_L CHOICE(popfl, popfl, _LTOG popf)
|
|---|
| 496 | #define POPF_W CHOICE(popfw, popfw, _WTOG popf)
|
|---|
| 497 | #define PUSH_SR(a) CHOICE(push a, push a, push a)
|
|---|
| 498 | #define PUSH_L(a) CHOICE(pushl a, pushl a, _LTOG push a)
|
|---|
| 499 | #define PUSH_W(a) CHOICE(pushw a, pushw a, _WTOG push a)
|
|---|
| 500 | #define PUSH_B(a) CHOICE(push a, pushb a, push a)
|
|---|
| 501 | #define PUSHA_L CHOICE(pushal, pushal, _LTOG pusha)
|
|---|
| 502 | #define PUSHA_W CHOICE(pushaw, pushaw, _WTOG pusha)
|
|---|
| 503 | #define PUSHF_L CHOICE(pushfl, pushfl, _LTOG pushf)
|
|---|
| 504 | #define PUSHF_W CHOICE(pushfw, pushfw, _WTOG pushf)
|
|---|
| 505 | #define RCL_L(a, b) CHOICE(rcll ARG2(a,b), rcll ARG2(a,b), _LTOG rcl ARG2(b,a))
|
|---|
| 506 | #define RCL_W(a, b) CHOICE(rclw ARG2(a,b), rclw ARG2(a,b), _WTOG rcl ARG2(b,a))
|
|---|
| 507 | #define RCL_B(a, b) CHOICE(rclb ARG2(a,b), rclb ARG2(a,b), rclb ARG2(b,a))
|
|---|
| 508 | #define RCR_L(a, b) CHOICE(rcrl ARG2(a,b), rcrl ARG2(a,b), _LTOG rcr ARG2(b,a))
|
|---|
| 509 | #define RCR_W(a, b) CHOICE(rcrw ARG2(a,b), rcrw ARG2(a,b), _WTOG rcr ARG2(b,a))
|
|---|
| 510 | #define RCR_B(a, b) CHOICE(rcrb ARG2(a,b), rcrb ARG2(a,b), rcrb ARG2(b,a))
|
|---|
| 511 | #define ROL_L(a, b) CHOICE(roll ARG2(a,b), roll ARG2(a,b), _LTOG rol ARG2(b,a))
|
|---|
| 512 | #define ROL_W(a, b) CHOICE(rolw ARG2(a,b), rolw ARG2(a,b), _WTOG rol ARG2(b,a))
|
|---|
| 513 | #define ROL_B(a, b) CHOICE(rolb ARG2(a,b), rolb ARG2(a,b), rolb ARG2(b,a))
|
|---|
| 514 | #define ROR_L(a, b) CHOICE(rorl ARG2(a,b), rorl ARG2(a,b), _LTOG ror ARG2(b,a))
|
|---|
| 515 | #define ROR_W(a, b) CHOICE(rorw ARG2(a,b), rorw ARG2(a,b), _WTOG ror ARG2(b,a))
|
|---|
| 516 | #define ROR_B(a, b) CHOICE(rorb ARG2(a,b), rorb ARG2(a,b), rorb ARG2(b,a))
|
|---|
| 517 | #define REP CHOICE(rep ;, rep ;, repe)
|
|---|
| 518 | #define REPE CHOICE(repz ;, repe ;, repe)
|
|---|
| 519 | #define REPNE CHOICE(repnz ;, repne ;, repne)
|
|---|
| 520 | #define REPNZ REPNE
|
|---|
| 521 | #define REPZ REPE
|
|---|
| 522 | #define RET CHOICE(ret, ret, ret)
|
|---|
| 523 | #define SAHF CHOICE(sahf, sahf, sahf)
|
|---|
| 524 | #define SAL_L(a, b) CHOICE(sall ARG2(a,b), sall ARG2(a,b), _LTOG sal ARG2(b,a))
|
|---|
| 525 | #define SAL_W(a, b) CHOICE(salw ARG2(a,b), salw ARG2(a,b), _WTOG sal ARG2(b,a))
|
|---|
| 526 | #define SAL_B(a, b) CHOICE(salb ARG2(a,b), salb ARG2(a,b), salb ARG2(b,a))
|
|---|
| 527 | #define SAR_L(a, b) CHOICE(sarl ARG2(a,b), sarl ARG2(a,b), _LTOG sar ARG2(b,a))
|
|---|
| 528 | #define SAR_W(a, b) CHOICE(sarw ARG2(a,b), sarw ARG2(a,b), _WTOG sar ARG2(b,a))
|
|---|
| 529 | #define SAR_B(a, b) CHOICE(sarb ARG2(a,b), sarb ARG2(a,b), sarb ARG2(b,a))
|
|---|
| 530 | #define SBB_L(a, b) CHOICE(sbbl ARG2(a,b), sbbl ARG2(a,b), _LTOG sbb ARG2(b,a))
|
|---|
| 531 | #define SBB_W(a, b) CHOICE(sbbw ARG2(a,b), sbbw ARG2(a,b), _WTOG sbb ARG2(b,a))
|
|---|
| 532 | #define SBB_B(a, b) CHOICE(sbbb ARG2(a,b), sbbb ARG2(a,b), sbbb ARG2(b,a))
|
|---|
| 533 | #define SCAS_L CHOICE(scasl, scasl, _LTOG scas)
|
|---|
| 534 | #define SCAS_W CHOICE(scasw, scasw, _WTOG scas)
|
|---|
| 535 | #define SCAS_B CHOICE(scasb, scasb, scasb)
|
|---|
| 536 | #define SETA(a) CHOICE(seta a, seta a, seta a)
|
|---|
| 537 | #define SETAE(a) CHOICE(setae a, setae a, setae a)
|
|---|
| 538 | #define SETB(a) CHOICE(setb a, setb a, setb a)
|
|---|
| 539 | #define SETBE(a) CHOICE(setbe a, setbe a, setbe a)
|
|---|
| 540 | #define SETC(a) CHOICE(setc a, setb a, setb a)
|
|---|
| 541 | #define SETE(a) CHOICE(sete a, sete a, sete a)
|
|---|
| 542 | #define SETG(a) CHOICE(setg a, setg a, setg a)
|
|---|
| 543 | #define SETGE(a) CHOICE(setge a, setge a, setge a)
|
|---|
| 544 | #define SETL(a) CHOICE(setl a, setl a, setl a)
|
|---|
| 545 | #define SETLE(a) CHOICE(setle a, setle a, setle a)
|
|---|
| 546 | #define SETNA(a) CHOICE(setna a, setna a, setna a)
|
|---|
| 547 | #define SETNAE(a) CHOICE(setnae a, setnae a, setnae a)
|
|---|
| 548 | #define SETNB(a) CHOICE(setnb a, setnb a, setnb a)
|
|---|
| 549 | #define SETNBE(a) CHOICE(setnbe a, setnbe a, setnbe a)
|
|---|
| 550 | #define SETNC(a) CHOICE(setnc a, setnb a, setnb a)
|
|---|
| 551 | #define SETNE(a) CHOICE(setne a, setne a, setne a)
|
|---|
| 552 | #define SETNG(a) CHOICE(setng a, setng a, setng a)
|
|---|
| 553 | #define SETNGE(a) CHOICE(setnge a, setnge a, setnge a)
|
|---|
| 554 | #define SETNL(a) CHOICE(setnl a, setnl a, setnl a)
|
|---|
| 555 | #define SETNLE(a) CHOICE(setnle a, setnle a, setnle a)
|
|---|
| 556 | #define SETNO(a) CHOICE(setno a, setno a, setno a)
|
|---|
| 557 | #define SETNP(a) CHOICE(setnp a, setnp a, setnp a)
|
|---|
| 558 | #define SETNS(a) CHOICE(setns a, setns a, setna a)
|
|---|
| 559 | #define SETNZ(a) CHOICE(setnz a, setnz a, setnz a)
|
|---|
| 560 | #define SETO(a) CHOICE(seto a, seto a, seto a)
|
|---|
| 561 | #define SETP(a) CHOICE(setp a, setp a, setp a)
|
|---|
| 562 | #define SETPE(a) CHOICE(setpe a, setpe a, setpe a)
|
|---|
| 563 | #define SETPO(a) CHOICE(setpo a, setpo a, setpo a)
|
|---|
| 564 | #define SETS(a) CHOICE(sets a, sets a, seta a)
|
|---|
| 565 | #define SETZ(a) CHOICE(setz a, setz a, setz a)
|
|---|
| 566 | #define SGDT(a) CHOICE(sgdt a, sgdt a, sgdt a)
|
|---|
| 567 | #define SIDT(a) CHOICE(sidt a, sidt a, sidt a)
|
|---|
| 568 | #define SHL_L(a, b) CHOICE(shll ARG2(a,b), shll ARG2(a,b), _LTOG shl ARG2(b,a))
|
|---|
| 569 | #define SHL_W(a, b) CHOICE(shlw ARG2(a,b), shlw ARG2(a,b), _WTOG shl ARG2(b,a))
|
|---|
| 570 | #define SHL_B(a, b) CHOICE(shlb ARG2(a,b), shlb ARG2(a,b), shlb ARG2(b,a))
|
|---|
| 571 | #define SHLD_L(a,b,c) CHOICE(shldl ARG3(a,b,c), shldl ARG3(a,b,c), _LTOG shld ARG3(c,b,a))
|
|---|
| 572 | #define SHLD2_L(a,b) CHOICE(shldl ARG2(a,b), shldl ARG3(CL,a,b), _LTOG shld ARG3(b,a,CL))
|
|---|
| 573 | #define SHLD_W(a,b,c) CHOICE(shldw ARG3(a,b,c), shldw ARG3(a,b,c), _WTOG shld ARG3(c,b,a))
|
|---|
| 574 | #define SHLD2_W(a,b) CHOICE(shldw ARG2(a,b), shldw ARG3(CL,a,b), _WTOG shld ARG3(b,a,CL))
|
|---|
| 575 | #define SHR_L(a, b) CHOICE(shrl ARG2(a,b), shrl ARG2(a,b), _LTOG shr ARG2(b,a))
|
|---|
| 576 | #define SHR_W(a, b) CHOICE(shrw ARG2(a,b), shrw ARG2(a,b), _WTOG shr ARG2(b,a))
|
|---|
| 577 | #define SHR_B(a, b) CHOICE(shrb ARG2(a,b), shrb ARG2(a,b), shrb ARG2(b,a))
|
|---|
| 578 | #define SHRD_L(a,b,c) CHOICE(shrdl ARG3(a,b,c), shrdl ARG3(a,b,c), _LTOG shrd ARG3(c,b,a))
|
|---|
| 579 | #define SHRD2_L(a,b) CHOICE(shrdl ARG2(a,b), shrdl ARG3(CL,a,b), _LTOG shrd ARG3(b,a,CL))
|
|---|
| 580 | #define SHRD_W(a,b,c) CHOICE(shrdw ARG3(a,b,c), shrdw ARG3(a,b,c), _WTOG shrd ARG3(c,b,a))
|
|---|
| 581 | #define SHRD2_W(a,b) CHOICE(shrdw ARG2(a,b), shrdw ARG3(CL,a,b), _WTOG shrd ARG3(b,a,CL))
|
|---|
| 582 | #define SLDT(a) CHOICE(sldt a, sldt a, sldt a)
|
|---|
| 583 | #define SMSW(a) CHOICE(smsw a, smsw a, smsw a)
|
|---|
| 584 | #define STC CHOICE(stc, stc, stc)
|
|---|
| 585 | #define STD CHOICE(std, std, std)
|
|---|
| 586 | #define STI CHOICE(sti, sti, sti)
|
|---|
| 587 | #define STOS_L CHOICE(stosl, stosl, _LTOG stos)
|
|---|
| 588 | #define STOS_W CHOICE(stosw, stosw, _WTOG stos)
|
|---|
| 589 | #define STOS_B CHOICE(stosb, stosb, stosb)
|
|---|
| 590 | #define STR(a) CHOICE(str a, str a, str a)
|
|---|
| 591 | #define SUB_L(a, b) CHOICE(subl ARG2(a,b), subl ARG2(a,b), _LTOG sub ARG2(b,a))
|
|---|
| 592 | #define SUB_W(a, b) CHOICE(subw ARG2(a,b), subw ARG2(a,b), _WTOG sub ARG2(b,a))
|
|---|
| 593 | #define SUB_B(a, b) CHOICE(subb ARG2(a,b), subb ARG2(a,b), subb ARG2(b,a))
|
|---|
| 594 | #define TEST_L(a, b) CHOICE(testl ARG2(a,b), testl ARG2(a,b), _LTOG test ARG2(b,a))
|
|---|
| 595 | #define TEST_W(a, b) CHOICE(testw ARG2(a,b), testw ARG2(a,b), _WTOG test ARG2(b,a))
|
|---|
| 596 | #define TEST_B(a, b) CHOICE(testb ARG2(a,b), testb ARG2(a,b), testb ARG2(b,a))
|
|---|
| 597 | #define VERR(a) CHOICE(verr a, verr a, verr a)
|
|---|
| 598 | #define VERW(a) CHOICE(verw a, verw a, verw a)
|
|---|
| 599 | #define WAIT CHOICE(wait, wait, wait)
|
|---|
| 600 | #define XCHG_L(a, b) CHOICE(xchgl ARG2(a,b), xchgl ARG2(a,b), _LTOG xchg ARG2(b,a))
|
|---|
| 601 | #define XCHG_W(a, b) CHOICE(xchgw ARG2(a,b), xchgw ARG2(a,b), _WTOG xchg ARG2(b,a))
|
|---|
| 602 | #define XCHG_B(a, b) CHOICE(xchgb ARG2(a,b), xchgb ARG2(a,b), xchgb ARG2(b,a))
|
|---|
| 603 | #define XLAT CHOICE(xlat, xlat, xlat)
|
|---|
| 604 | #define XOR_L(a, b) CHOICE(xorl ARG2(a,b), xorl ARG2(a,b), _LTOG xor ARG2(b,a))
|
|---|
| 605 | #define XOR_W(a, b) CHOICE(xorw ARG2(a,b), xorw ARG2(a,b), _WTOG xor ARG2(b,a))
|
|---|
| 606 | #define XOR_B(a, b) CHOICE(xorb ARG2(a,b), xorb ARG2(a,b), xorb ARG2(b,a))
|
|---|
| 607 |
|
|---|
| 608 |
|
|---|
| 609 | /* Floating Point Instructions */
|
|---|
| 610 | #define F2XM1 CHOICE(f2xm1, f2xm1, f2xm1)
|
|---|
| 611 | #define FABS CHOICE(fabs, fabs, fabs)
|
|---|
| 612 | #define FADD_D(a) CHOICE(faddl a, faddl a, faddd a)
|
|---|
| 613 | #define FADD_S(a) CHOICE(fadds a, fadds a, fadds a)
|
|---|
| 614 | #define FADD2(a, b) CHOICE(fadd ARG2(a,b), fadd ARG2(a,b), fadd ARG2(b,a))
|
|---|
| 615 | #define FADDP(a, b) CHOICE(faddp ARG2(a,b), faddp ARG2(a,b), faddp ARG2(b,a))
|
|---|
| 616 | #define FIADD_L(a) CHOICE(fiaddl a, fiaddl a, fiaddl a)
|
|---|
| 617 | #define FIADD_W(a) CHOICE(fiadd a, fiadds a, fiadds a)
|
|---|
| 618 | #define FBLD(a) CHOICE(fbld a, fbld a, fbld a)
|
|---|
| 619 | #define FBSTP(a) CHOICE(fbstp a, fbstp a, fbstp a)
|
|---|
| 620 | #define FCHS CHOICE(fchs, fchs, fchs)
|
|---|
| 621 | #define FCLEX CHOICE(fclex, wait; fnclex, wait; fclex)
|
|---|
| 622 | #define FNCLEX CHOICE(fnclex, fnclex, fclex)
|
|---|
| 623 | #define FCOM(a) CHOICE(fcom a, fcom a, fcom a)
|
|---|
| 624 | #define FCOM_D(a) CHOICE(fcoml a, fcoml a, fcomd a)
|
|---|
| 625 | #define FCOM_S(a) CHOICE(fcoms a, fcoms a, fcoms a)
|
|---|
| 626 | #define FCOMP(a) CHOICE(fcomp a, fcomp a, fcomp a)
|
|---|
| 627 | #define FCOMP_D(a) CHOICE(fcompl a, fcompl a, fcompd a)
|
|---|
| 628 | #define FCOMP_S(a) CHOICE(fcomps a, fcomps a, fcomps a)
|
|---|
| 629 | #define FCOMPP CHOICE(fcompp, fcompp, fcompp)
|
|---|
| 630 | #define FCOS CHOICE(fcos, fcos, fcos)
|
|---|
| 631 | #define FDECSTP CHOICE(fdecstp, fdecstp, fdecstp)
|
|---|
| 632 | #define FDIV_D(a) CHOICE(fdivl a, fdivl a, fdivd a)
|
|---|
| 633 | #define FDIV_S(a) CHOICE(fdivs a, fdivs a, fdivs a)
|
|---|
| 634 | #define FDIV2(a, b) CHOICE(fdiv ARG2(a,b), fdiv ARG2(a,b), fdiv ARG2(b,a))
|
|---|
| 635 | #define FDIVP(a, b) CHOICE(fdivp ARG2(a,b), fdivp ARG2(a,b), fdivp ARG2(b,a))
|
|---|
| 636 | #define FIDIV_L(a) CHOICE(fidivl a, fidivl a, fidivl a)
|
|---|
| 637 | #define FIDIV_W(a) CHOICE(fidiv a, fidivs a, fidivs a)
|
|---|
| 638 | #define FDIVR_D(a) CHOICE(fdivrl a, fdivrl a, fdivrd a)
|
|---|
| 639 | #define FDIVR_S(a) CHOICE(fdivrs a, fdivrs a, fdivrs a)
|
|---|
| 640 | #define FDIVR2(a, b) CHOICE(fdivr ARG2(a,b), fdivr ARG2(a,b), fdivr ARG2(b,a))
|
|---|
| 641 | #define FDIVRP(a, b) CHOICE(fdivrp ARG2(a,b), fdivrp ARG2(a,b), fdivrp ARG2(b,a))
|
|---|
| 642 | #define FIDIVR_L(a) CHOICE(fidivrl a, fidivrl a, fidivrl a)
|
|---|
| 643 | #define FIDIVR_W(a) CHOICE(fidivr a, fidivrs a, fidivrs a)
|
|---|
| 644 | #define FFREE(a) CHOICE(ffree a, ffree a, ffree a)
|
|---|
| 645 | #define FICOM_L(a) CHOICE(ficoml a, ficoml a, ficoml a)
|
|---|
| 646 | #define FICOM_W(a) CHOICE(ficom a, ficoms a, ficoms a)
|
|---|
| 647 | #define FICOMP_L(a) CHOICE(ficompl a, ficompl a, ficompl a)
|
|---|
| 648 | #define FICOMP_W(a) CHOICE(ficomp a, ficomps a, ficomps a)
|
|---|
| 649 | #define FILD_Q(a) CHOICE(fildll a, fildq a, fildq a)
|
|---|
| 650 | #define FILD_L(a) CHOICE(fildl a, fildl a, fildl a)
|
|---|
| 651 | #define FILD_W(a) CHOICE(fild a, filds a, filds a)
|
|---|
| 652 | #define FINCSTP CHOICE(fincstp, fincstp, fincstp)
|
|---|
| 653 | #define FINIT CHOICE(finit, wait; fninit, wait; finit)
|
|---|
| 654 | #define FNINIT CHOICE(fninit, fninit, finit)
|
|---|
| 655 | #define FIST_L(a) CHOICE(fistl a, fistl a, fistl a)
|
|---|
| 656 | #define FIST_W(a) CHOICE(fist a, fists a, fists a)
|
|---|
| 657 | #define FISTP_Q(a) CHOICE(fistpll a, fistpq a, fistpq a)
|
|---|
| 658 | #define FISTP_L(a) CHOICE(fistpl a, fistpl a, fistpl a)
|
|---|
| 659 | #define FISTP_W(a) CHOICE(fistp a, fistps a, fistps a)
|
|---|
| 660 | #define FLD_X(a) CHOICE(fldt a, fldt a, fldx a) /* 80 bit data type! */
|
|---|
| 661 | #define FLD_D(a) CHOICE(fldl a, fldl a, fldd a)
|
|---|
| 662 | #define FLD_S(a) CHOICE(flds a, flds a, flds a)
|
|---|
| 663 | #define FLD1 CHOICE(fld1, fld1, fld1)
|
|---|
| 664 | #define FLDL2T CHOICE(fldl2t, fldl2t, fldl2t)
|
|---|
| 665 | #define FLDL2E CHOICE(fldl2e, fldl2e, fldl2e)
|
|---|
| 666 | #define FLDPI CHOICE(fldpi, fldpi, fldpi)
|
|---|
| 667 | #define FLDLG2 CHOICE(fldlg2, fldlg2, fldlg2)
|
|---|
| 668 | #define FLDLN2 CHOICE(fldln2, fldln2, fldln2)
|
|---|
| 669 | #define FLDZ CHOICE(fldz, fldz, fldz)
|
|---|
| 670 | #define FLDCW(a) CHOICE(fldcw a, fldcw a, fldcw a)
|
|---|
| 671 | #define FLDENV(a) CHOICE(fldenv a, fldenv a, fldenv a)
|
|---|
| 672 | #define FMUL_S(a) CHOICE(fmuls a, fmuls a, fmuls a)
|
|---|
| 673 | #define FMUL_D(a) CHOICE(fmull a, fmull a, fmuld a)
|
|---|
| 674 | #define FMUL2(a, b) CHOICE(fmul ARG2(a,b), fmul ARG2(a,b), fmul ARG2(b,a))
|
|---|
| 675 | #define FMULP(a, b) CHOICE(fmulp ARG2(a,b), fmulp ARG2(a,b), fmulp ARG2(b,a))
|
|---|
| 676 | #define FIMUL_L(a) CHOICE(fimull a, fimull a, fimull a)
|
|---|
| 677 | #define FIMUL_W(a) CHOICE(fimul a, fimuls a, fimuls a)
|
|---|
| 678 | #define FNOP CHOICE(fnop, fnop, fnop)
|
|---|
| 679 | #define FPATAN CHOICE(fpatan, fpatan, fpatan)
|
|---|
| 680 | #define FPREM CHOICE(fprem, fprem, fprem)
|
|---|
| 681 | #define FPREM1 CHOICE(fprem1, fprem1, fprem1)
|
|---|
| 682 | #define FPTAN CHOICE(fptan, fptan, fptan)
|
|---|
| 683 | #define FRNDINT CHOICE(frndint, frndint, frndint)
|
|---|
| 684 | #define FRSTOR(a) CHOICE(frstor a, frstor a, frstor a)
|
|---|
| 685 | #define FSAVE(a) CHOICE(fsave a, wait; fnsave a, wait; fsave a)
|
|---|
| 686 | #define FNSAVE(a) CHOICE(fnsave a, fnsave a, fsave a)
|
|---|
| 687 | #define FSCALE CHOICE(fscale, fscale, fscale)
|
|---|
| 688 | #define FSIN CHOICE(fsin, fsin, fsin)
|
|---|
| 689 | #define FSINCOS CHOICE(fsincos, fsincos, fsincos)
|
|---|
| 690 | #define FSQRT CHOICE(fsqrt, fsqrt, fsqrt)
|
|---|
| 691 | #define FST_D(a) CHOICE(fstl a, fstl a, fstd a)
|
|---|
| 692 | #define FST_S(a) CHOICE(fsts a, fsts a, fsts a)
|
|---|
| 693 | #define FSTP_X(a) CHOICE(fstpt a, fstpt a, fstpx a)
|
|---|
| 694 | #define FSTP_D(a) CHOICE(fstpl a, fstpl a, fstpd a)
|
|---|
| 695 | #define FSTP_S(a) CHOICE(fstps a, fstps a, fstps a)
|
|---|
| 696 | #define FSTCW(a) CHOICE(fstcw a, wait; fnstcw a, wait; fstcw a)
|
|---|
| 697 | #define FNSTCW(a) CHOICE(fnstcw a, fnstcw a, fstcw a)
|
|---|
| 698 | #define FSTENV(a) CHOICE(fstenv a, wait; fnstenv a, fstenv a)
|
|---|
| 699 | #define FNSTENV(a) CHOICE(fnstenv a, fnstenv a, fstenv a)
|
|---|
| 700 | #define FSTSW(a) CHOICE(fstsw a, wait; fnstsw a, wait; fstsw a)
|
|---|
| 701 | #define FNSTSW(a) CHOICE(fnstsw a, fnstsw a, fstsw a)
|
|---|
| 702 | #define FSUB_S(a) CHOICE(fsubs a, fsubs a, fsubs a)
|
|---|
| 703 | #define FSUB_D(a) CHOICE(fsubl a, fsubl a, fsubd a)
|
|---|
| 704 | #define FSUB2(a, b) CHOICE(fsub ARG2(a,b), fsub ARG2(a,b), fsub ARG2(b,a))
|
|---|
| 705 | #define FSUBP(a, b) CHOICE(fsubp ARG2(a,b), fsubp ARG2(a,b), fsubp ARG2(b,a))
|
|---|
| 706 | #define FISUB_L(a) CHOICE(fisubl a, fisubl a, fisubl a)
|
|---|
| 707 | #define FISUB_W(a) CHOICE(fisub a, fisubs a, fisubs a)
|
|---|
| 708 | #define FSUBR_S(a) CHOICE(fsubrs a, fsubrs a, fsubrs a)
|
|---|
| 709 | #define FSUBR_D(a) CHOICE(fsubrl a, fsubrl a, fsubrd a)
|
|---|
| 710 | #define FSUBR2(a, b) CHOICE(fsubr ARG2(a,b), fsubr ARG2(a,b), fsubr ARG2(b,a))
|
|---|
| 711 | #define FSUBRP(a, b) CHOICE(fsubrp ARG2(a,b), fsubrp ARG2(a,b), fsubrp ARG2(b,a))
|
|---|
| 712 | #define FISUBR_L(a) CHOICE(fisubrl a, fisubrl a, fisubrl a)
|
|---|
| 713 | #define FISUBR_W(a) CHOICE(fisubr a, fisubrs a, fisubrs a)
|
|---|
| 714 | #define FTST CHOICE(ftst, ftst, ftst)
|
|---|
| 715 | #define FUCOM(a) CHOICE(fucom a, fucom a, fucom a)
|
|---|
| 716 | #define FUCOMP(a) CHOICE(fucomp a, fucomp a, fucomp a)
|
|---|
| 717 | #define FUCOMPP CHOICE(fucompp, fucompp, fucompp)
|
|---|
| 718 | #define FWAIT CHOICE(wait, wait, wait)
|
|---|
| 719 | #define FXAM CHOICE(fxam, fxam, fxam)
|
|---|
| 720 | #define FXCH(a) CHOICE(fxch a, fxch a, fxch a)
|
|---|
| 721 | #define FXTRACT CHOICE(fxtract, fxtract, fxtract)
|
|---|
| 722 | #define FYL2X CHOICE(fyl2x, fyl2x, fyl2x)
|
|---|
| 723 | #define FYL2XP1 CHOICE(fyl2xp1, fyl2xp1, fyl2xp1)
|
|---|
| 724 |
|
|---|
| 725 | #endif /* __ASSYNTAX_H__ */
|
|---|
