1 // [AsmJit] 2 // Machine Code Generation for C++. 3 // 4 // [License] 5 // Zlib - See LICENSE.md file in the package. 6 7 #ifndef _ASMJIT_TEST_OPCODE_H 8 #define _ASMJIT_TEST_OPCODE_H 9 10 #include "./asmjit.h" 11 12 namespace asmtest { 13 14 // Generate all instructions asmjit can emit. 15 static void generateOpcodes(asmjit::x86::Emitter* e, bool useRex1 = false, bool useRex2 = false) { 16 using namespace asmjit; 17 using namespace asmjit::x86; 18 19 bool isX64 = e->is64Bit(); 20 21 // Prevent a crash when the generated function is called to see the disassembly. 22 e->ret(); 23 24 // All instructions use the following register that can be changed to see if 25 // `x86::Assembler` can properly encode all possible combinations. If the given 26 // `useRexRegs` argument is true the `A` version will in most cases contain 27 // a register having index 8 or greater to force REX prefix. 28 Gp gLoA = useRex1 ? r8b : al; 29 Gp gLoB = useRex2 ? r9b : bl; 30 31 Gp gHiA = ah; 32 Gp gHiB = bh; 33 34 Gp gwA = useRex1 ? r8w : ax; 35 Gp gwB = useRex2 ? r9w : bx; 36 37 Gp gdA = useRex1 ? r8d : eax; 38 Gp gdB = useRex2 ? r9d : ebx; 39 Gp gdC = useRex2 ? r10d : ecx; 40 41 Gp gzA = useRex1 ? r8 : e->zax(); 42 Gp gzB = useRex2 ? r9 : e->zbx(); 43 Gp gzC = useRex2 ? r10 : e->zcx(); 44 Gp gzD = useRex2 ? r11 : e->zdx(); 45 46 KReg kA = k1; 47 KReg kB = k2; 48 KReg kC = k3; 49 50 Mem anyptr_gpA = ptr(gzA); 51 Mem anyptr_gpB = ptr(gzB); 52 Mem anyptr_gpC = ptr(gzC); 53 Mem anyptr_gpD = ptr(gzD); 54 55 Mem intptr_gpA = e->intptr_ptr(gzA); 56 Mem intptr_gpB = e->intptr_ptr(gzB); 57 58 St stA = st0; 59 St stB = st7; 60 61 Mm mmA = mm0; 62 Mm mmB = mm1; 63 64 Xmm xmmA = useRex1 ? xmm8 : xmm0; 65 Xmm xmmB = useRex2 ? xmm9 : xmm1; 66 Xmm xmmC = useRex2 ? xmm10 : xmm2; 67 Xmm xmmD = useRex2 ? xmm11 : xmm3; 68 69 Ymm ymmA = useRex1 ? ymm8 : ymm0; 70 Ymm ymmB = useRex2 ? ymm9 : ymm1; 71 Ymm ymmC = useRex2 ? ymm10 : ymm2; 72 Ymm ymmD = useRex2 ? ymm11 : ymm3; 73 74 Zmm zmmA = useRex1 ? zmm8 : zmm0; 75 Zmm zmmB = useRex2 ? zmm9 : zmm1; 76 Zmm zmmC = useRex2 ? zmm10 : zmm2; 77 Zmm zmmD = useRex2 ? zmm11 : zmm3; 78 79 Mem vx_ptr = ptr(gzB, xmmB); 80 Mem vy_ptr = ptr(gzB, ymmB); 81 Mem vz_ptr = ptr(gzB, zmmB); 82 83 Label L; 84 85 // Base. 86 e->adc(gLoA, 1); 87 e->adc(gLoB, 1); 88 e->adc(gHiA, 1); 89 e->adc(gHiB, 1); 90 e->adc(gwA, 1); 91 e->adc(gwB, 1); 92 e->adc(gdA, 1); 93 e->adc(gdB, 1); 94 e->adc(gzA, 1); 95 e->adc(gzA, gzB); 96 e->adc(gzA, intptr_gpB); 97 e->adc(intptr_gpA, 1); 98 e->adc(intptr_gpA, gzB); 99 e->add(gLoA, 1); 100 e->add(gLoB, 1); 101 e->add(gHiA, 1); 102 e->add(gHiB, 1); 103 e->add(gwA, 1); 104 e->add(gwB, 1); 105 e->add(gdA, 1); 106 e->add(gdB, 1); 107 e->add(gzA, 1); 108 e->add(gzA, gzB); 109 e->add(gzA, intptr_gpB); 110 e->add(intptr_gpA, 1); 111 e->add(intptr_gpA, gzB); 112 e->and_(gLoA, 1); 113 e->and_(gLoB, 1); 114 e->and_(gHiA, 1); 115 e->and_(gHiB, 1); 116 e->and_(gwA, 1); 117 e->and_(gwB, 1); 118 e->and_(gdA, 1); 119 e->and_(gdB, 1); 120 e->and_(gzA, 1); 121 e->and_(gzA, gzB); 122 e->and_(gzA, intptr_gpB); 123 e->and_(intptr_gpA, 1); 124 e->and_(intptr_gpA, gzB); 125 e->bswap(gzA); 126 e->bt(gdA, 1); 127 e->bt(gzA, 1); 128 e->bt(gdA, gdB); 129 e->bt(gzA, gzB); 130 e->bt(intptr_gpA, 1); 131 e->bt(anyptr_gpA, gdB); 132 e->bt(intptr_gpA, gzB); 133 e->btc(gdA, 1); 134 e->btc(gzA, 1); 135 e->btc(gdA, gdB); 136 e->btc(gzA, gzB); 137 e->btc(intptr_gpA, 1); 138 e->btc(anyptr_gpA, gdB); 139 e->btc(intptr_gpA, gzB); 140 e->btr(gdA, 1); 141 e->btr(gzA, 1); 142 e->btr(gdA, gdB); 143 e->btr(gzA, gzB); 144 e->btr(intptr_gpA, 1); 145 e->btr(anyptr_gpA, gdB); 146 e->btr(intptr_gpA, gzB); 147 e->bts(gdA, 1); 148 e->bts(gzA, 1); 149 e->bts(gdA, gdB); 150 e->bts(gzA, gzB); 151 e->bts(intptr_gpA, 1); 152 e->bts(anyptr_gpA, gdB); 153 e->bts(intptr_gpA, gzB); 154 e->call(gzA); 155 e->call(intptr_gpA); 156 e->cbw(); // Implicit AX <- Sign Extend AL. 157 e->cbw(ax); // Explicit AX <- Sign Extend AL. 158 e->cdq(); // Implicit EDX:EAX <- Sign Extend EAX. 159 e->cdq(edx, eax); // Explicit EDX:EAX <- Sign Extend EAX. 160 if (isX64) e->cdqe(); // Implicit RAX <- Sign Extend EAX. 161 if (isX64) e->cdqe(eax); // Explicit RAX <- Sign Extend EAX. 162 e->cwd(); // Implicit DX:AX <- Sign Extend AX. 163 e->cwd(dx, ax); // Explicit DX:AX <- Sign Extend AX. 164 e->cwde(); // Implicit EAX <- Sign Extend AX. 165 e->cwde(eax); // Explicit EAX <- Sign Extend AX. 166 if (isX64) e->cqo(); // Implicit RDX:RAX <- Sign Extend RAX. 167 if (isX64) e->cqo(rdx, rax); // Explicit RDX:RAX <- Sign Extend RAX. 168 e->clc(); 169 e->cld(); 170 e->cmc(); 171 e->cmp(gLoA, 1); 172 e->cmp(gLoB, 1); 173 e->cmp(gHiA, 1); 174 e->cmp(gHiB, 1); 175 e->cmp(gwA, 1); 176 e->cmp(gwB, 1); 177 e->cmp(gdA, 1); 178 e->cmp(gdB, 1); 179 e->cmp(gzA, 1); 180 e->cmp(gLoA, gLoB); 181 e->cmp(gHiA, gHiB); 182 e->cmp(gwA, gwB); 183 e->cmp(gdA, gdB); 184 e->cmp(gzA, gzB); 185 e->cmp(gdA, anyptr_gpB); 186 e->cmp(gzA, intptr_gpB); 187 e->cmp(intptr_gpA, 1); 188 e->cmp(anyptr_gpA, gdB); 189 e->cmp(intptr_gpA, gzB); 190 e->cmpxchg(gdA, gdB); // Implicit regA, regB, <EAX> 191 e->cmpxchg(gzA, gzB); // Implicit regA, regB, <ZAX> 192 e->cmpxchg(gdA, gdB, eax); // Explicit regA, regB, <EAX> 193 e->cmpxchg(gzA, gzB, e->zax()); // Explicit regA, regB, <ZAX> 194 e->cmpxchg(anyptr_gpA, gdB); // Implicit mem , regB, <EAX> 195 e->cmpxchg(anyptr_gpA, gzB); // Implicit mem , regB, <ZAX> 196 e->cmpxchg(anyptr_gpA, gdB, eax); // Explicit mem , regB, <EAX> 197 e->cmpxchg(anyptr_gpA, gzB, e->zax()); // Explicit mem , regB, <ZAX> 198 e->cmpxchg8b(anyptr_gpA); // Implicit mem , <EDX>, <EAX>, <ECX>, <EBX> 199 e->cmpxchg8b(anyptr_gpA, 200 x86::edx, x86::eax, 201 x86::ecx, x86::ebx); // Explicit mem , <EDX>, <EAX>, <ECX>, <EBX> 202 if (isX64) e->cmpxchg16b(anyptr_gpA); // Implicit mem , <RDX>, <RAX>, <RCX>, <RBX> 203 if (isX64) e->cmpxchg16b(anyptr_gpA, 204 x86::rdx, x86::rax, 205 x86::rcx, x86::rbx); // Explicit mem , <EDX>, <EAX>, <ECX>, <EBX> 206 e->cpuid(); // Implicit <EAX>, <EBX>, <ECX>, <EDX> 207 e->cpuid(eax, ebx, ecx, edx); // Explicit <EAX>, <EBX>, <ECX>, <EDX> 208 e->crc32(gdA, byte_ptr(gzB)); 209 e->crc32(gdA, word_ptr(gzB)); 210 e->crc32(gdA, dword_ptr(gzB)); 211 if (isX64) e->crc32(gdA, qword_ptr(gzB)); 212 if (isX64) e->crc32(gzA, qword_ptr(gzB)); 213 e->dec(gLoA); 214 e->dec(gHiA); 215 e->dec(gwA); 216 e->dec(gdA); 217 e->dec(gzA); 218 e->dec(intptr_gpA); 219 e->inc(gLoA); 220 e->inc(gwA); 221 e->inc(gdA); 222 e->inc(gzA); 223 e->inc(intptr_gpA); 224 e->int_(13); 225 e->int3(); 226 e->into(); 227 e->lea(gzA, intptr_gpB); 228 e->mov(gLoA, 1); 229 e->mov(gHiA, 1); 230 e->mov(gwA, 1); 231 e->mov(gdA, 1); 232 e->mov(gzA, 1); 233 e->mov(gLoA, gLoB); 234 e->mov(gHiA, gHiB); 235 e->mov(gwA, gwB); 236 e->mov(gdA, gdB); 237 e->mov(gzA, gzB); 238 e->mov(gLoA, anyptr_gpB); 239 e->mov(gwA, anyptr_gpB); 240 e->mov(gdA, anyptr_gpB); 241 e->mov(gzA, intptr_gpB); 242 e->mov(anyptr_gpA, gLoB); 243 e->mov(anyptr_gpA, gwB); 244 e->mov(anyptr_gpA, gdB); 245 e->mov(intptr_gpA, 1); 246 e->mov(intptr_gpA, gzB); 247 e->movsx(gzA, gLoB); 248 e->movsx(gzA, byte_ptr(gzB)); 249 e->movzx(gzA, gLoB); 250 e->movzx(gzA, byte_ptr(gzB)); 251 e->movbe(gzA, anyptr_gpB); 252 e->movbe(anyptr_gpA, gzB); 253 e->neg(gzA); 254 e->neg(intptr_gpA); 255 e->nop(); 256 e->not_(gzA); 257 e->not_(intptr_gpA); 258 e->or_(gLoA, 1); 259 e->or_(gLoB, 1); 260 e->or_(gHiA, 1); 261 e->or_(gHiB, 1); 262 e->or_(gwA, 1); 263 e->or_(gwB, 1); 264 e->or_(gdA, 1); 265 e->or_(gdB, 1); 266 e->or_(gzA, 1); 267 e->or_(gzA, gzB); 268 e->or_(gzA, intptr_gpB); 269 e->or_(intptr_gpA, 1); 270 e->or_(intptr_gpA, gzB); 271 e->pop(gzA); 272 e->pop(intptr_gpA); 273 if (!isX64) e->popa(); 274 if (!isX64) e->popad(); 275 e->popf(); 276 if (!isX64) e->popfd(); 277 if ( isX64) e->popfq(); 278 e->push(gzA); 279 e->push(intptr_gpA); 280 e->push(0); 281 if (!isX64) e->pusha(); 282 if (!isX64) e->pushad(); 283 e->pushf(); 284 if (!isX64) e->pushfd(); 285 if ( isX64) e->pushfq(); 286 e->rcl(gdA, 0); 287 e->rcl(gzA, 0); 288 e->rcl(gdA, 1); 289 e->rcl(gzA, 1); 290 e->rcl(gdA, cl); 291 e->rcl(gzA, cl); 292 e->rcl(intptr_gpA, 0); 293 e->rcl(intptr_gpA, 1); 294 e->rcl(intptr_gpA, cl); 295 e->rcr(gdA, 0); 296 e->rcr(gzA, 0); 297 e->rcr(gdA, 1); 298 e->rcr(gzA, 1); 299 e->rcr(gdA, cl); 300 e->rcr(gzA, cl); 301 e->rcr(intptr_gpA, 0); 302 e->rcr(intptr_gpA, 1); 303 e->rcr(intptr_gpA, cl); 304 e->rdtsc(); // Implicit <EDX:EAX> 305 e->rdtsc(edx, eax); // Explicit <EDX:EAX> 306 e->rdtscp(); // Implicit <EDX:EAX>, <ECX> 307 e->rdtscp(edx, eax, ecx); // Implicit <EDX:EAX>, <ECX> 308 e->ret(); 309 e->ret(0); 310 e->rol(gdA, 0); 311 e->rol(gzA, 0); 312 e->rol(gdA, 1); 313 e->rol(gzA, 1); 314 e->rol(gdA, cl); 315 e->rol(gzA, cl); 316 e->rol(intptr_gpA, 0); 317 e->rol(intptr_gpA, 1); 318 e->rol(intptr_gpA, cl); 319 e->ror(gdA, 0); 320 e->ror(gzA, 0); 321 e->ror(gdA, 1); 322 e->ror(gzA, 1); 323 e->ror(gdA, cl); 324 e->ror(gzA, cl); 325 e->ror(intptr_gpA, 0); 326 e->ror(intptr_gpA, 1); 327 e->ror(intptr_gpA, cl); 328 e->sbb(gLoA, 1); 329 e->sbb(gLoB, 1); 330 e->sbb(gHiA, 1); 331 e->sbb(gHiB, 1); 332 e->sbb(gwA, 1); 333 e->sbb(gwB, 1); 334 e->sbb(gdA, 1); 335 e->sbb(gdB, 1); 336 e->sbb(gzA, 1); 337 e->sbb(gzA, gzB); 338 e->sbb(gzA, intptr_gpB); 339 e->sbb(intptr_gpA, 1); 340 e->sbb(intptr_gpA, gzB); 341 e->sal(gdA, 0); 342 e->sal(gzA, 0); 343 e->sal(gdA, 1); 344 e->sal(gzA, 1); 345 e->sal(gdA, cl); 346 e->sal(gzA, cl); 347 e->sal(intptr_gpA, 0); 348 e->sal(intptr_gpA, 1); 349 e->sal(intptr_gpA, cl); 350 e->sar(gdA, 0); 351 e->sar(gzA, 0); 352 e->sar(gdA, 1); 353 e->sar(gzA, 1); 354 e->sar(gdA, cl); 355 e->sar(gzA, cl); 356 e->sar(intptr_gpA, 0); 357 e->sar(intptr_gpA, 1); 358 e->sar(intptr_gpA, cl); 359 e->shl(gdA, 0); 360 e->shl(gzA, 0); 361 e->shl(gdA, 1); 362 e->shl(gzA, 1); 363 e->shl(gdA, cl); 364 e->shl(gzA, cl); 365 e->shl(intptr_gpA, 0); 366 e->shl(intptr_gpA, 1); 367 e->shl(intptr_gpA, cl); 368 e->shr(gdA, 0); 369 e->shr(gzA, 0); 370 e->shr(gdA, 1); 371 e->shr(gzA, 1); 372 e->shr(gdA, cl); 373 e->shr(gzA, cl); 374 e->shr(intptr_gpA, 0); 375 e->shr(intptr_gpA, 1); 376 e->shr(intptr_gpA, cl); 377 e->shld(gdA, gdB, 0); 378 e->shld(gzA, gzB, 0); 379 e->shld(gdA, gdB, cl); 380 e->shld(gzA, gzB, cl); 381 e->shld(anyptr_gpA, gdB, 0); 382 e->shld(intptr_gpA, gzB, 0); 383 e->shld(anyptr_gpA, gdB, cl); 384 e->shld(intptr_gpA, gzB, cl); 385 e->shrd(gdA, gdB, 0); 386 e->shrd(gzA, gzB, 0); 387 e->shrd(gdA, gdB, cl); 388 e->shrd(gzA, gzB, cl); 389 e->shrd(anyptr_gpA, gdB, 0); 390 e->shrd(intptr_gpA, gzB, 0); 391 e->shrd(anyptr_gpA, gdB, cl); 392 e->shrd(intptr_gpA, gzB, cl); 393 e->stc(); 394 e->std(); 395 e->sti(); 396 e->sub(gLoA, 1); 397 e->sub(gLoB, 1); 398 e->sub(gHiA, 1); 399 e->sub(gHiB, 1); 400 e->sub(gwA, 1); 401 e->sub(gwB, 1); 402 e->sub(gdA, 1); 403 e->sub(gdB, 1); 404 e->sub(gzA, 1); 405 e->sub(gzA, gzB); 406 e->sub(gzA, intptr_gpB); 407 e->sub(intptr_gpA, 1); 408 e->sub(intptr_gpA, gzB); 409 e->swapgs(); 410 e->test(gzA, 1); 411 e->test(gzA, gzB); 412 e->test(intptr_gpA, 1); 413 e->test(intptr_gpA, gzB); 414 e->ud2(); 415 e->xadd(gzA, gzB); 416 e->xadd(intptr_gpA, gzB); 417 e->xchg(gzA, gzB); 418 e->xchg(intptr_gpA, gzB); 419 e->xchg(gzA, intptr_gpB); 420 e->xor_(gLoA, 1); 421 e->xor_(gLoB, 1); 422 e->xor_(gHiA, 1); 423 e->xor_(gHiB, 1); 424 e->xor_(gwA, 1); 425 e->xor_(gwB, 1); 426 e->xor_(gdA, 1); 427 e->xor_(gdB, 1); 428 e->xor_(gzA, 1); 429 e->xor_(gzA, gzB); 430 e->xor_(gzA, intptr_gpB); 431 e->xor_(intptr_gpA, 1); 432 e->xor_(intptr_gpA, gzB); 433 434 // Special case - div|mul. 435 e->div(cl); // Implicit AH:AL <- AX * r8 436 e->div(byte_ptr(gzA)); // Implicit AH:AL <- AX * m8 437 e->div(ax, cl); // Explicit AH:AL <- AX * r8 438 e->div(ax, anyptr_gpA); // Explicit AH:AL <- AX * m8 439 440 e->div(cx); // Implicit DX:AX <- DX:AX * r16 441 e->div(word_ptr(gzA)); // Implicit DX:AX <- DX:AX * m16 442 e->div(dx, ax, cx); // Explicit DX:AX <- DX:AX * r16 443 e->div(dx, ax, anyptr_gpA); // Explicit DX:AX <- DX:AX * m16 444 445 e->div(ecx); // Implicit EDX:EAX <- EDX:EAX * r32 446 e->div(dword_ptr(gzA)); // Implicit EDX:EAX <- EDX:EAX * m32 447 e->div(edx, eax, ecx); // Explicit EDX:EAX <- EDX:EAX * r32 448 e->div(edx, eax, anyptr_gpA); // Explicit EDX:EAX <- EDX:EAX * m32 449 450 if (isX64) e->div(rcx); // Implicit RDX|RAX <- RDX:RAX * r64 451 if (isX64) e->div(qword_ptr(gzA)); // Implicit RDX|RAX <- RDX:RAX * m64 452 if (isX64) e->div(rdx, rax, rcx); // Explicit RDX|RAX <- RDX:RAX * r64 453 if (isX64) e->div(rdx, rax, anyptr_gpA); // Explicit RDX|RAX <- RDX:RAX * m64 454 455 e->idiv(cl); // Implicit AH:AL <- AX * r8 456 e->idiv(byte_ptr(gzA)); // Implicit AH:AL <- AX * m8 457 e->idiv(ax, cl); // Explicit AH:AL <- AX * r8 458 e->idiv(ax, anyptr_gpA); // Explicit AH:AL <- AX * m8 459 460 e->idiv(cx); // Implicit DX:AX <- DX:AX * r16 461 e->idiv(word_ptr(gzA)); // Implicit DX:AX <- DX:AX * m16 462 e->idiv(dx, ax, cx); // Explicit DX:AX <- DX:AX * r16 463 e->idiv(dx, ax, anyptr_gpA); // Explicit DX:AX <- DX:AX * m16 464 465 e->idiv(ecx); // Implicit EDX:EAX <- EDX:EAX * r32 466 e->idiv(dword_ptr(gzA)); // Implicit EDX:EAX <- EDX:EAX * m32 467 e->idiv(edx, eax, ecx); // Explicit EDX:EAX <- EDX:EAX * r32 468 e->idiv(edx, eax, anyptr_gpA); // Explicit EDX:EAX <- EDX:EAX * m32 469 470 if (isX64) e->idiv(rcx); // Implicit RDX|RAX <- RDX:RAX * r64 471 if (isX64) e->idiv(qword_ptr(gzA)); // Implicit RDX|RAX <- RDX:RAX * m64 472 if (isX64) e->idiv(rdx, rax, rcx); // Explicit RDX|RAX <- RDX:RAX * r64 473 if (isX64) e->idiv(rdx, rax, anyptr_gpA); // Explicit RDX|RAX <- RDX:RAX * m64 474 475 e->mul(cl); // Implicit AX <- AL * r8 476 e->mul(byte_ptr(gzA)); // Implicit AX <- AL * m8 477 e->mul(ax, cl); // Explicit AX <- AL * r8 478 e->mul(ax, anyptr_gpA); // Explicit AX <- AL * m8 479 480 e->mul(cx); // Implicit DX:AX <- AX * r16 481 e->mul(word_ptr(gzA)); // Implicit DX:AX <- AX * m16 482 e->mul(dx, ax, cx); // Explicit DX:AX <- AX * r16 483 e->mul(dx, ax, anyptr_gpA); // Explicit DX:AX <- AX * m16 484 485 e->mul(ecx); // Implicit EDX:EAX <- EAX * r32 486 e->mul(dword_ptr(gzA)); // Implicit EDX:EAX <- EAX * m32 487 e->mul(edx, eax, ecx); // Explicit EDX:EAX <- EAX * r32 488 e->mul(edx, eax, anyptr_gpA); // Explicit EDX:EAX <- EAX * m32 489 490 if (isX64) e->mul(rcx); // Implicit RDX|RAX <- RAX * r64 491 if (isX64) e->mul(qword_ptr(gzA)); // Implicit RDX|RAX <- RAX * m64 492 if (isX64) e->mul(rdx, rax, rcx); // Explicit RDX|RAX <- RAX * r64 493 if (isX64) e->mul(rdx, rax, anyptr_gpA); // Explicit RDX|RAX <- RAX * m64 494 495 e->imul(gdA); 496 e->imul(gzA); 497 e->imul(intptr_gpA); 498 e->imul(gdA, 1); 499 e->imul(gzA, 1); 500 e->imul(gdA, gdB); 501 e->imul(gzA, gzB); 502 e->imul(gdA, gdB, 1); 503 e->imul(gzA, gzB, 1); 504 e->imul(gdA, anyptr_gpB); 505 e->imul(gzA, intptr_gpB); 506 e->imul(gdA, anyptr_gpB, 1); 507 e->imul(gzA, intptr_gpB, 1); 508 509 // Special case - zero-extend 32-bit immediate instead of sign-extend: 510 if (isX64) e->mov(gzA, uint32_t(0xFEEDFEED)); 511 if (isX64) e->and_(gzA, uint32_t(0xFEEDFEED)); 512 513 // Special case - mov with absolute 32-bit address. 514 e->mov(al , ptr(0x01020304u)); 515 e->mov(ax , ptr(0x01020304u)); 516 e->mov(eax, ptr(0x01020304u)); 517 e->mov(ptr(0x01020304u), al ); 518 e->mov(ptr(0x01020304u), ax ); 519 e->mov(ptr(0x01020304u), eax); 520 521 // Special case - mov with absolute 64-bit address. 522 if (isX64) e->mov(al , ptr(0x0102030405060708u)); 523 if (isX64) e->mov(ax , ptr(0x0102030405060708u)); 524 if (isX64) e->mov(eax, ptr(0x0102030405060708u)); 525 if (isX64) e->mov(rax, ptr(0x0102030405060708u)); 526 if (isX64) e->mov(ptr(0x0102030405060708u), al ); 527 if (isX64) e->mov(ptr(0x0102030405060708u), ax ); 528 if (isX64) e->mov(ptr(0x0102030405060708u), eax); 529 if (isX64) e->mov(ptr(0x0102030405060708u), rax); 530 531 // Control registers. 532 e->nop(); 533 534 e->mov(gzA, cr0); 535 e->mov(cr0, gzA); 536 if (isX64) e->mov(gzA, cr8); 537 if (isX64) e->mov(cr8, gzA); 538 539 // Debug registers. 540 e->nop(); 541 542 e->mov(gzA, dr0); 543 e->mov(dr0, gzA); 544 545 // Segment registers. 546 e->nop(); 547 548 if (!isX64) e->mov(es, ax); 549 if (!isX64) e->mov(es, bx); 550 if (!isX64) e->mov(ax, es); 551 if (!isX64) e->mov(bx, es); 552 553 if (!isX64) e->mov(cs, ax); 554 if (!isX64) e->mov(cs, bx); 555 if (!isX64) e->mov(ax, cs); 556 if (!isX64) e->mov(bx, cs); 557 558 if (!isX64) e->mov(ss, ax); 559 if (!isX64) e->mov(ss, bx); 560 if (!isX64) e->mov(ax, ss); 561 if (!isX64) e->mov(bx, ss); 562 563 if (!isX64) e->mov(ds, ax); 564 if (!isX64) e->mov(ds, bx); 565 if (!isX64) e->mov(ax, ds); 566 if (!isX64) e->mov(bx, ds); 567 568 e->mov(fs, ax); 569 e->mov(fs, bx); 570 e->mov(ax, fs); 571 e->mov(bx, fs); 572 573 e->mov(gs, ax); 574 e->mov(gs, bx); 575 e->mov(ax, gs); 576 e->mov(bx, gs); 577 578 // Instructions using REP prefix. 579 e->nop(); 580 581 e->in(al, 0); 582 e->in(al, dx); 583 e->in(ax, 0); 584 e->in(ax, dx); 585 e->in(eax, 0); 586 e->in(eax, dx); 587 e->rep().ins(byte_ptr(e->zdi()), dx); 588 e->rep().ins(word_ptr(e->zdi()), dx); 589 e->rep().ins(dword_ptr(e->zdi()), dx); 590 591 e->out(imm(0), al); 592 e->out(dx, al); 593 e->out(imm(0), ax); 594 e->out(dx, ax); 595 e->out(imm(0), eax); 596 e->out(dx, eax); 597 e->rep().outs(dx, byte_ptr(e->zsi())); 598 e->rep().outs(dx, word_ptr(e->zsi())); 599 e->rep().outs(dx, dword_ptr(e->zsi())); 600 601 e->lodsb(); 602 e->lodsd(); 603 e->lodsw(); 604 e->rep().lodsb(); 605 e->rep().lodsd(); 606 e->rep().lodsw(); 607 if (isX64) e->rep().lodsq(); 608 609 e->movsb(); 610 e->movsd(); 611 e->movsw(); 612 e->rep().movsb(); 613 e->rep().movsd(); 614 e->rep().movsw(); 615 if (isX64) e->rep().movsq(); 616 617 e->stosb(); 618 e->stosd(); 619 e->stosw(); 620 e->rep().stosb(); 621 e->rep().stosd(); 622 e->rep().stosw(); 623 if (isX64) e->rep().stosq(); 624 625 e->cmpsb(); 626 e->cmpsd(); 627 e->cmpsw(); 628 e->repz().cmpsb(); 629 e->repz().cmpsd(); 630 e->repz().cmpsw(); 631 if (isX64) e->repz().cmpsq(); 632 e->repnz().cmpsb(); 633 e->repnz().cmpsd(); 634 e->repnz().cmpsw(); 635 if (isX64) e->repnz().cmpsq(); 636 637 e->scasb(); 638 e->scasd(); 639 e->scasw(); 640 e->repz().scasb(); 641 e->repz().scasd(); 642 e->repz().scasw(); 643 if (isX64) e->repz().scasq(); 644 e->repnz().scasb(); 645 e->repnz().scasd(); 646 e->repnz().scasw(); 647 if (isX64) e->repnz().scasq(); 648 649 // Label...Jcc/Jecxz/Jmp. 650 e->nop(); 651 652 L = e->newLabel(); 653 e->bind(L); 654 e->ja(L); 655 e->jae(L); 656 e->jb(L); 657 e->jbe(L); 658 e->jc(L); 659 e->je(L); 660 e->jg(L); 661 e->jge(L); 662 e->jl(L); 663 e->jle(L); 664 e->jna(L); 665 e->jnae(L); 666 e->jnb(L); 667 e->jnbe(L); 668 e->jnc(L); 669 e->jne(L); 670 e->jng(L); 671 e->jnge(L); 672 e->jnl(L); 673 e->jnle(L); 674 e->jno(L); 675 e->jnp(L); 676 e->jns(L); 677 e->jnz(L); 678 e->jo(L); 679 e->jp(L); 680 e->jpe(L); 681 e->jpo(L); 682 e->js(L); 683 e->jz(L); 684 e->jecxz(ecx, L); 685 e->jmp(L); 686 687 // Jcc/Jecxz/Jmp...Label. 688 e->nop(); 689 690 L = e->newLabel(); 691 e->ja(L); 692 e->jae(L); 693 e->jb(L); 694 e->jbe(L); 695 e->jc(L); 696 e->je(L); 697 e->jg(L); 698 e->jge(L); 699 e->jl(L); 700 e->jle(L); 701 e->jna(L); 702 e->jnae(L); 703 e->jnb(L); 704 e->jnbe(L); 705 e->jnc(L); 706 e->jne(L); 707 e->jng(L); 708 e->jnge(L); 709 e->jnl(L); 710 e->jnle(L); 711 e->jno(L); 712 e->jnp(L); 713 e->jns(L); 714 e->jnz(L); 715 e->jo(L); 716 e->jp(L); 717 e->jpe(L); 718 e->jpo(L); 719 e->js(L); 720 e->jz(L); 721 e->jecxz(ecx, L); 722 e->jmp(L); 723 e->bind(L); 724 725 // FPU. 726 e->nop(); 727 728 e->f2xm1(); 729 e->fabs(); 730 e->fadd(stA, stB); 731 e->fadd(stB, stA); 732 e->fadd(dword_ptr(gzA)); 733 e->fadd(qword_ptr(gzA)); 734 e->faddp(stB); 735 e->faddp(); 736 e->fbld(dword_ptr(gzA)); 737 e->fbstp(dword_ptr(gzA)); 738 e->fchs(); 739 e->fclex(); 740 e->fcom(stB); 741 e->fcom(); 742 e->fcom(dword_ptr(gzA)); 743 e->fcom(qword_ptr(gzA)); 744 e->fcomp(stB); 745 e->fcomp(); 746 e->fcomp(dword_ptr(gzA)); 747 e->fcomp(qword_ptr(gzA)); 748 e->fcompp(); 749 e->fcos(); 750 e->fdecstp(); 751 e->fdiv(stA, stB); 752 e->fdiv(stB, stA); 753 e->fdiv(dword_ptr(gzA)); 754 e->fdiv(qword_ptr(gzA)); 755 e->fdivp(stB); 756 e->fdivp(); 757 e->fdivr(stA, stB); 758 e->fdivr(stB, stA); 759 e->fdivr(dword_ptr(gzA)); 760 e->fdivr(qword_ptr(gzA)); 761 e->fdivrp(stB); 762 e->fdivrp(); 763 e->fiadd(dword_ptr(gzA)); 764 e->ficom(word_ptr(gzA)); 765 e->ficom(dword_ptr(gzA)); 766 e->ficomp(word_ptr(gzA)); 767 e->ficomp(dword_ptr(gzA)); 768 e->fidiv(word_ptr(gzA)); 769 e->fidiv(dword_ptr(gzA)); 770 e->fidivr(word_ptr(gzA)); 771 e->fidivr(dword_ptr(gzA)); 772 e->fild(word_ptr(gzA)); 773 e->fild(dword_ptr(gzA)); 774 e->fild(qword_ptr(gzA)); 775 e->fimul(word_ptr(gzA)); 776 e->fimul(dword_ptr(gzA)); 777 e->fincstp(); 778 e->finit(); 779 e->fninit(); 780 e->fisub(word_ptr(gzA)); 781 e->fisub(dword_ptr(gzA)); 782 e->fisubr(word_ptr(gzA)); 783 e->fisubr(dword_ptr(gzA)); 784 e->fist(word_ptr(gzA)); 785 e->fist(dword_ptr(gzA)); 786 e->fistp(word_ptr(gzA)); 787 e->fistp(dword_ptr(gzA)); 788 e->fistp(qword_ptr(gzA)); 789 e->fld(dword_ptr(gzA)); 790 e->fld(qword_ptr(gzA)); 791 e->fld(tword_ptr(gzA)); 792 e->fld1(); 793 e->fldl2t(); 794 e->fldl2e(); 795 e->fldpi(); 796 e->fldlg2(); 797 e->fldln2(); 798 e->fldz(); 799 e->fldcw(anyptr_gpA); 800 e->fldenv(anyptr_gpA); 801 e->fmul(stA, stB); 802 e->fmul(stB, stA); 803 e->fmul(dword_ptr(gzA)); 804 e->fmul(qword_ptr(gzA)); 805 e->fmulp(stB); 806 e->fmulp(); 807 e->fnclex(); 808 e->fnop(); 809 e->fnsave(anyptr_gpA); 810 e->fnstenv(anyptr_gpA); 811 e->fnstcw(anyptr_gpA); 812 e->fpatan(); 813 e->fprem(); 814 e->fprem1(); 815 e->fptan(); 816 e->frndint(); 817 e->frstor(anyptr_gpA); 818 e->fsave(anyptr_gpA); 819 e->fscale(); 820 e->fsin(); 821 e->fsincos(); 822 e->fsqrt(); 823 e->fst(dword_ptr(gzA)); 824 e->fst(qword_ptr(gzA)); 825 e->fstp(dword_ptr(gzA)); 826 e->fstp(qword_ptr(gzA)); 827 e->fstp(tword_ptr(gzA)); 828 e->fstcw(anyptr_gpA); 829 e->fstenv(anyptr_gpA); 830 e->fsub(stA, stB); 831 e->fsub(stB, stA); 832 e->fsub(dword_ptr(gzA)); 833 e->fsub(qword_ptr(gzA)); 834 e->fsubp(stB); 835 e->fsubp(); 836 e->fsubr(stA, stB); 837 e->fsubr(stB, stA); 838 e->fsubr(dword_ptr(gzA)); 839 e->fsubr(qword_ptr(gzA)); 840 e->fsubrp(stB); 841 e->fsubrp(); 842 e->ftst(); 843 e->fucom(stB); 844 e->fucom(); 845 e->fucom(stB); 846 e->fucomi(stB); 847 e->fucomip(stB); 848 e->fucomp(stB); 849 e->fucompp(); 850 e->fxam(); 851 e->fxtract(); 852 e->fyl2x(); 853 e->fyl2xp1(); 854 855 // LAHF/SAHF 856 e->lahf(); // Implicit <AH> 857 e->lahf(ah); // Explicit <AH> 858 e->sahf(); // Implicit <AH> 859 e->sahf(ah); // Explicit <AH> 860 861 // FXSR. 862 e->fxrstor(anyptr_gpA); 863 e->fxsave(anyptr_gpA); 864 865 // XSAVE. 866 e->nop(); 867 868 e->xgetbv(); // Implicit <EDX:EAX>, <ECX> 869 e->xgetbv(edx, eax, ecx); // Explicit <EDX:EAX>, <ECX> 870 871 e->xsetbv(); // Implicit <EDX:EAX>, <ECX> 872 e->xsetbv(edx, eax, ecx); // Explicit <EDX:EAX>, <ECX> 873 874 e->xrstor(anyptr_gpA); // Implicit <EDX:EAX> 875 e->xrstors(anyptr_gpA); // Implicit <EDX:EAX> 876 e->xsave(anyptr_gpA); // Implicit <EDX:EAX> 877 e->xsavec(anyptr_gpA); // Implicit <EDX:EAX> 878 e->xsaveopt(anyptr_gpA); // Implicit <EDX:EAX> 879 e->xsaves(anyptr_gpA); // Implicit <EDX:EAX> 880 881 if (isX64) e->xrstor64(anyptr_gpA); // Implicit <EDX:EAX> 882 if (isX64) e->xrstors64(anyptr_gpA); // Implicit <EDX:EAX> 883 if (isX64) e->xsave64(anyptr_gpA); // Implicit <EDX:EAX> 884 if (isX64) e->xsavec64(anyptr_gpA); // Implicit <EDX:EAX> 885 if (isX64) e->xsaveopt64(anyptr_gpA); // Implicit <EDX:EAX> 886 if (isX64) e->xsaves64(anyptr_gpA); // Implicit <EDX:EAX> 887 888 // POPCNT. 889 e->nop(); 890 891 e->popcnt(gdA, gdB); 892 e->popcnt(gzA, gzB); 893 e->popcnt(gdA, anyptr_gpB); 894 e->popcnt(gzA, anyptr_gpB); 895 896 // LZCNT. 897 e->nop(); 898 899 e->lzcnt(gdA, gdB); 900 e->lzcnt(gzA, gzB); 901 e->lzcnt(gdA, anyptr_gpB); 902 e->lzcnt(gzA, anyptr_gpB); 903 904 // BMI. 905 e->nop(); 906 907 e->andn(gdA, gdB, gdC); 908 e->andn(gzA, gzB, gzC); 909 e->andn(gdA, gdB, anyptr_gpC); 910 e->andn(gzA, gzB, anyptr_gpC); 911 e->bextr(gdA, gdB, gdC); 912 e->bextr(gzA, gzB, gzC); 913 e->bextr(gdA, anyptr_gpB, gdC); 914 e->bextr(gzA, anyptr_gpB, gzC); 915 e->blsi(gdA, gdB); 916 e->blsi(gzA, gzB); 917 e->blsi(gdA, anyptr_gpB); 918 e->blsi(gzA, anyptr_gpB); 919 e->blsmsk(gdA, gdB); 920 e->blsmsk(gzA, gzB); 921 e->blsmsk(gdA, anyptr_gpB); 922 e->blsmsk(gzA, anyptr_gpB); 923 e->blsr(gdA, gdB); 924 e->blsr(gzA, gzB); 925 e->blsr(gdA, anyptr_gpB); 926 e->blsr(gzA, anyptr_gpB); 927 e->tzcnt(gdA, gdB); 928 e->tzcnt(gzA, gzB); 929 e->tzcnt(gdA, anyptr_gpB); 930 e->tzcnt(gzA, anyptr_gpB); 931 932 // BMI2. 933 e->nop(); 934 935 e->bzhi(gdA, gdB, gdC); 936 e->bzhi(gzA, gzB, gzC); 937 e->bzhi(gdA, anyptr_gpB, gdC); 938 e->bzhi(gzA, anyptr_gpB, gzC); 939 e->mulx(gdA, gdB, gdC); // Implicit gpA, gpB, gpC, <EDX> 940 e->mulx(gdA, gdB, gdC, edx); // Explicit gpA, gpB, gpC, <EDX> 941 e->mulx(gzA, gzB, gzC); // Implicit gpA, gpB, gpC, <EDX|RDX> 942 e->mulx(gzA, gzB, gzC, e->zdx()); // Explicit gpA, gpB, gpC, <EDX|RDX> 943 e->mulx(gdA, gdB, anyptr_gpC); // Implicit gpA, gpB, mem, <EDX> 944 e->mulx(gdA, gdB, anyptr_gpC, edx); // Explicit gpA, gpB, mem, <EDX> 945 e->mulx(gzA, gzB, anyptr_gpC); // Implicit gpA, gpB, mem, <EDX|RDX> 946 e->mulx(gzA, gzB, anyptr_gpC, e->zdx()); // Explicit gpA, gpB, mem, <EDX|RDX> 947 e->pdep(gdA, gdB, gdC); 948 e->pdep(gzA, gzB, gzC); 949 e->pdep(gdA, gdB, anyptr_gpC); 950 e->pdep(gzA, gzB, anyptr_gpC); 951 e->pext(gdA, gdB, gdC); 952 e->pext(gzA, gzB, gzC); 953 e->pext(gdA, gdB, anyptr_gpC); 954 e->pext(gzA, gzB, anyptr_gpC); 955 e->rorx(gdA, gdB, 0); 956 e->rorx(gzA, gzB, 0); 957 e->rorx(gdA, anyptr_gpB, 0); 958 e->rorx(gzA, anyptr_gpB, 0); 959 e->sarx(gdA, gdB, gdC); 960 e->sarx(gzA, gzB, gzC); 961 e->sarx(gdA, anyptr_gpB, gdC); 962 e->sarx(gzA, anyptr_gpB, gzC); 963 e->shlx(gdA, gdB, gdC); 964 e->shlx(gzA, gzB, gzC); 965 e->shlx(gdA, anyptr_gpB, gdC); 966 e->shlx(gzA, anyptr_gpB, gzC); 967 e->shrx(gdA, gdB, gdC); 968 e->shrx(gzA, gzB, gzC); 969 e->shrx(gdA, anyptr_gpB, gdC); 970 e->shrx(gzA, anyptr_gpB, gzC); 971 972 // ADX. 973 e->nop(); 974 975 e->adcx(gdA, gdB); 976 e->adcx(gzA, gzB); 977 e->adcx(gdA, anyptr_gpB); 978 e->adcx(gzA, anyptr_gpB); 979 e->adox(gdA, gdB); 980 e->adox(gzA, gzB); 981 e->adox(gdA, anyptr_gpB); 982 e->adox(gzA, anyptr_gpB); 983 984 // TBM. 985 e->nop(); 986 987 e->blcfill(gdA, gdB); 988 e->blcfill(gzA, gzB); 989 e->blcfill(gdA, anyptr_gpB); 990 e->blcfill(gzA, anyptr_gpB); 991 992 e->blci(gdA, gdB); 993 e->blci(gzA, gzB); 994 e->blci(gdA, anyptr_gpB); 995 e->blci(gzA, anyptr_gpB); 996 997 e->blcic(gdA, gdB); 998 e->blcic(gzA, gzB); 999 e->blcic(gdA, anyptr_gpB); 1000 e->blcic(gzA, anyptr_gpB); 1001 1002 e->blcmsk(gdA, gdB); 1003 e->blcmsk(gzA, gzB); 1004 e->blcmsk(gdA, anyptr_gpB); 1005 e->blcmsk(gzA, anyptr_gpB); 1006 1007 e->blcs(gdA, gdB); 1008 e->blcs(gzA, gzB); 1009 e->blcs(gdA, anyptr_gpB); 1010 e->blcs(gzA, anyptr_gpB); 1011 1012 e->blsfill(gdA, gdB); 1013 e->blsfill(gzA, gzB); 1014 e->blsfill(gdA, anyptr_gpB); 1015 e->blsfill(gzA, anyptr_gpB); 1016 1017 e->blsic(gdA, gdB); 1018 e->blsic(gzA, gzB); 1019 e->blsic(gdA, anyptr_gpB); 1020 e->blsic(gzA, anyptr_gpB); 1021 1022 e->t1mskc(gdA, gdB); 1023 e->t1mskc(gzA, gzB); 1024 e->t1mskc(gdA, anyptr_gpB); 1025 e->t1mskc(gzA, anyptr_gpB); 1026 1027 e->tzmsk(gdA, gdB); 1028 e->tzmsk(gzA, gzB); 1029 e->tzmsk(gdA, anyptr_gpB); 1030 e->tzmsk(gzA, anyptr_gpB); 1031 1032 // CLFLUSH / CLFLUSH_OPT. 1033 e->nop(); 1034 e->clflush(anyptr_gpA); 1035 e->clflushopt(anyptr_gpA); 1036 1037 // CLWB. 1038 e->nop(); 1039 e->clwb(anyptr_gpA); 1040 1041 // CLZERO. 1042 e->nop(); 1043 e->clzero(); // Implicit <ds:[EAX|RAX]> 1044 e->clzero(ptr(e->zax())); // Explicit <ds:[EAX|RAX]> 1045 1046 // MONITOR[X] / MWAIT[X]. 1047 e->nop(); 1048 e->monitor(); // Implicit <ds:[EAX|RAX]>, <ECX>, <EDX> 1049 e->monitorx(); // Implicit <ds:[EAX|RAX]>, <ECX>, <EDX> 1050 e->mwait(); // Implicit <EAX>, <ECX> 1051 e->mwaitx(); // Implicit <EAX>, <ECX>, <EBX> 1052 1053 // PCOMMIT. 1054 e->nop(); 1055 e->pcommit(); 1056 1057 // PREFETCH / PREFETCHW / PREFETCHWT1. 1058 e->nop(); 1059 e->prefetch(anyptr_gpA); // 3DNOW. 1060 e->prefetchnta(anyptr_gpA); // MMX+SSE. 1061 e->prefetcht0(anyptr_gpA); // MMX+SSE. 1062 e->prefetcht1(anyptr_gpA); // MMX+SSE. 1063 e->prefetcht2(anyptr_gpA); // MMX+SSE. 1064 e->prefetchw(anyptr_gpA); // PREFETCHW. 1065 e->prefetchwt1(anyptr_gpA); // PREFETCHWT1. 1066 1067 // RDRAND / RDSEED. 1068 e->nop(); 1069 1070 e->rdrand(gdA); 1071 e->rdrand(gzA); 1072 e->rdseed(gdA); 1073 e->rdseed(gzA); 1074 1075 // MMX/MMX2. 1076 e->nop(); 1077 1078 e->movd(anyptr_gpA, mmB); 1079 e->movd(gdA, mmB); 1080 e->movd(mmA, anyptr_gpB); 1081 e->movd(mmA, gdB); 1082 e->movq(mmA, mmB); 1083 e->movq(anyptr_gpA, mmB); 1084 e->movq(mmA, anyptr_gpB); 1085 e->packuswb(mmA, mmB); 1086 e->packuswb(mmA, anyptr_gpB); 1087 e->paddb(mmA, mmB); 1088 e->paddb(mmA, anyptr_gpB); 1089 e->paddw(mmA, mmB); 1090 e->paddw(mmA, anyptr_gpB); 1091 e->paddd(mmA, mmB); 1092 e->paddd(mmA, anyptr_gpB); 1093 e->paddsb(mmA, mmB); 1094 e->paddsb(mmA, anyptr_gpB); 1095 e->paddsw(mmA, mmB); 1096 e->paddsw(mmA, anyptr_gpB); 1097 e->paddusb(mmA, mmB); 1098 e->paddusb(mmA, anyptr_gpB); 1099 e->paddusw(mmA, mmB); 1100 e->paddusw(mmA, anyptr_gpB); 1101 e->pand(mmA, mmB); 1102 e->pand(mmA, anyptr_gpB); 1103 e->pandn(mmA, mmB); 1104 e->pandn(mmA, anyptr_gpB); 1105 e->pcmpeqb(mmA, mmB); 1106 e->pcmpeqb(mmA, anyptr_gpB); 1107 e->pcmpeqw(mmA, mmB); 1108 e->pcmpeqw(mmA, anyptr_gpB); 1109 e->pcmpeqd(mmA, mmB); 1110 e->pcmpeqd(mmA, anyptr_gpB); 1111 e->pcmpgtb(mmA, mmB); 1112 e->pcmpgtb(mmA, anyptr_gpB); 1113 e->pcmpgtw(mmA, mmB); 1114 e->pcmpgtw(mmA, anyptr_gpB); 1115 e->pcmpgtd(mmA, mmB); 1116 e->pcmpgtd(mmA, anyptr_gpB); 1117 e->pmulhw(mmA, mmB); 1118 e->pmulhw(mmA, anyptr_gpB); 1119 e->pmullw(mmA, mmB); 1120 e->pmullw(mmA, anyptr_gpB); 1121 e->por(mmA, mmB); 1122 e->por(mmA, anyptr_gpB); 1123 e->pmaddwd(mmA, mmB); 1124 e->pmaddwd(mmA, anyptr_gpB); 1125 e->pslld(mmA, mmB); 1126 e->pslld(mmA, anyptr_gpB); 1127 e->pslld(mmA, 0); 1128 e->psllq(mmA, mmB); 1129 e->psllq(mmA, anyptr_gpB); 1130 e->psllq(mmA, 0); 1131 e->psllw(mmA, mmB); 1132 e->psllw(mmA, anyptr_gpB); 1133 e->psllw(mmA, 0); 1134 e->psrad(mmA, mmB); 1135 e->psrad(mmA, anyptr_gpB); 1136 e->psrad(mmA, 0); 1137 e->psraw(mmA, mmB); 1138 e->psraw(mmA, anyptr_gpB); 1139 e->psraw(mmA, 0); 1140 e->psrld(mmA, mmB); 1141 e->psrld(mmA, anyptr_gpB); 1142 e->psrld(mmA, 0); 1143 e->psrlq(mmA, mmB); 1144 e->psrlq(mmA, anyptr_gpB); 1145 e->psrlq(mmA, 0); 1146 e->psrlw(mmA, mmB); 1147 e->psrlw(mmA, anyptr_gpB); 1148 e->psrlw(mmA, 0); 1149 e->psubb(mmA, mmB); 1150 e->psubb(mmA, anyptr_gpB); 1151 e->psubw(mmA, mmB); 1152 e->psubw(mmA, anyptr_gpB); 1153 e->psubd(mmA, mmB); 1154 e->psubd(mmA, anyptr_gpB); 1155 e->psubsb(mmA, mmB); 1156 e->psubsb(mmA, anyptr_gpB); 1157 e->psubsw(mmA, mmB); 1158 e->psubsw(mmA, anyptr_gpB); 1159 e->psubusb(mmA, mmB); 1160 e->psubusb(mmA, anyptr_gpB); 1161 e->psubusw(mmA, mmB); 1162 e->psubusw(mmA, anyptr_gpB); 1163 e->punpckhbw(mmA, mmB); 1164 e->punpckhbw(mmA, anyptr_gpB); 1165 e->punpckhwd(mmA, mmB); 1166 e->punpckhwd(mmA, anyptr_gpB); 1167 e->punpckhdq(mmA, mmB); 1168 e->punpckhdq(mmA, anyptr_gpB); 1169 e->punpcklbw(mmA, mmB); 1170 e->punpcklbw(mmA, anyptr_gpB); 1171 e->punpcklwd(mmA, mmB); 1172 e->punpcklwd(mmA, anyptr_gpB); 1173 e->punpckldq(mmA, mmB); 1174 e->punpckldq(mmA, anyptr_gpB); 1175 e->pxor(mmA, mmB); 1176 e->pxor(mmA, anyptr_gpB); 1177 e->emms(); 1178 1179 // 3DNOW. 1180 e->nop(); 1181 1182 e->pavgusb(mmA, mmB); 1183 e->pavgusb(mmA, anyptr_gpB); 1184 e->pf2id(mmA, mmB); 1185 e->pf2id(mmA, anyptr_gpB); 1186 e->pf2iw(mmA, mmB); 1187 e->pf2iw(mmA, anyptr_gpB); 1188 e->pfacc(mmA, mmB); 1189 e->pfacc(mmA, anyptr_gpB); 1190 e->pfadd(mmA, mmB); 1191 e->pfadd(mmA, anyptr_gpB); 1192 e->pfcmpeq(mmA, mmB); 1193 e->pfcmpeq(mmA, anyptr_gpB); 1194 e->pfcmpge(mmA, mmB); 1195 e->pfcmpge(mmA, anyptr_gpB); 1196 e->pfcmpgt(mmA, mmB); 1197 e->pfcmpgt(mmA, anyptr_gpB); 1198 e->pfmax(mmA, mmB); 1199 e->pfmax(mmA, anyptr_gpB); 1200 e->pfmin(mmA, mmB); 1201 e->pfmin(mmA, anyptr_gpB); 1202 e->pfmul(mmA, mmB); 1203 e->pfmul(mmA, anyptr_gpB); 1204 e->pfnacc(mmA, mmB); 1205 e->pfnacc(mmA, anyptr_gpB); 1206 e->pfpnacc(mmA, mmB); 1207 e->pfpnacc(mmA, anyptr_gpB); 1208 e->pfrcp(mmA, mmB); 1209 e->pfrcp(mmA, anyptr_gpB); 1210 e->pfrcpit1(mmA, mmB); 1211 e->pfrcpit1(mmA, anyptr_gpB); 1212 e->pfrcpit2(mmA, mmB); 1213 e->pfrcpit2(mmA, anyptr_gpB); 1214 e->pfrcpv(mmA, mmB); 1215 e->pfrcpv(mmA, anyptr_gpB); 1216 e->pfrsqit1(mmA, mmB); 1217 e->pfrsqit1(mmA, anyptr_gpB); 1218 e->pfrsqrt(mmA, mmB); 1219 e->pfrsqrt(mmA, anyptr_gpB); 1220 e->pfrsqrtv(mmA, mmB); 1221 e->pfrsqrtv(mmA, anyptr_gpB); 1222 e->pfsub(mmA, mmB); 1223 e->pfsub(mmA, anyptr_gpB); 1224 e->pfsubr(mmA, mmB); 1225 e->pfsubr(mmA, anyptr_gpB); 1226 e->pi2fd(mmA, mmB); 1227 e->pi2fd(mmA, anyptr_gpB); 1228 e->pi2fw(mmA, mmB); 1229 e->pi2fw(mmA, anyptr_gpB); 1230 e->pmulhrw(mmA, mmB); 1231 e->pmulhrw(mmA, anyptr_gpB); 1232 e->pswapd(mmA, mmB); 1233 e->pswapd(mmA, anyptr_gpB); 1234 e->femms(); 1235 1236 // SSE. 1237 e->nop(); 1238 1239 e->addps(xmmA, xmmB); 1240 e->addps(xmmA, anyptr_gpB); 1241 e->addss(xmmA, xmmB); 1242 e->addss(xmmA, anyptr_gpB); 1243 e->andnps(xmmA, xmmB); 1244 e->andnps(xmmA, anyptr_gpB); 1245 e->andps(xmmA, xmmB); 1246 e->andps(xmmA, anyptr_gpB); 1247 e->cmpps(xmmA, xmmB, 0); 1248 e->cmpps(xmmA, anyptr_gpB, 0); 1249 e->cmpss(xmmA, xmmB, 0); 1250 e->cmpss(xmmA, anyptr_gpB, 0); 1251 e->comiss(xmmA, xmmB); 1252 e->comiss(xmmA, anyptr_gpB); 1253 e->cvtpi2ps(xmmA, mmB); 1254 e->cvtpi2ps(xmmA, anyptr_gpB); 1255 e->cvtps2pi(mmA, xmmB); 1256 e->cvtps2pi(mmA, anyptr_gpB); 1257 e->cvtsi2ss(xmmA, gdB); 1258 e->cvtsi2ss(xmmA, gzB); 1259 e->cvtsi2ss(xmmA, anyptr_gpB); 1260 e->cvtss2si(gdA, xmmB); 1261 e->cvtss2si(gzA, xmmB); 1262 e->cvtss2si(gdA, anyptr_gpB); 1263 e->cvtss2si(gzA, anyptr_gpB); 1264 e->cvttps2pi(mmA, xmmB); 1265 e->cvttps2pi(mmA, anyptr_gpB); 1266 e->cvttss2si(gdA, xmmB); 1267 e->cvttss2si(gzA, xmmB); 1268 e->cvttss2si(gdA, anyptr_gpB); 1269 e->cvttss2si(gzA, anyptr_gpB); 1270 e->divps(xmmA, xmmB); 1271 e->divps(xmmA, anyptr_gpB); 1272 e->divss(xmmA, xmmB); 1273 e->divss(xmmA, anyptr_gpB); 1274 e->ldmxcsr(anyptr_gpA); 1275 e->maskmovq(mmA, mmB); // Implicit mmA, mmB, <ds:[EDI|RDI]> 1276 e->maskmovq(mmA, mmB, ptr(e->zdi())); // Explicit mmA, mmB, <ds:[EDI|RDI]> 1277 e->maxps(xmmA, xmmB); 1278 e->maxps(xmmA, anyptr_gpB); 1279 e->maxss(xmmA, xmmB); 1280 e->maxss(xmmA, anyptr_gpB); 1281 e->minps(xmmA, xmmB); 1282 e->minps(xmmA, anyptr_gpB); 1283 e->minss(xmmA, xmmB); 1284 e->minss(xmmA, anyptr_gpB); 1285 e->movaps(xmmA, xmmB); 1286 e->movaps(xmmA, anyptr_gpB); 1287 e->movaps(anyptr_gpA, xmmB); 1288 e->movd(anyptr_gpA, xmmB); 1289 e->movd(gdA, xmmB); 1290 e->movd(gzA, xmmB); 1291 e->movd(xmmA, anyptr_gpB); 1292 e->movd(xmmA, gdB); 1293 e->movd(xmmA, gzB); 1294 e->movq(mmA, mmB); 1295 e->movq(xmmA, xmmB); 1296 e->movq(anyptr_gpA, xmmB); 1297 e->movq(xmmA, anyptr_gpB); 1298 e->movntq(anyptr_gpA, mmB); 1299 e->movhlps(xmmA, xmmB); 1300 e->movhps(xmmA, anyptr_gpB); 1301 e->movhps(anyptr_gpA, xmmB); 1302 e->movlhps(xmmA, xmmB); 1303 e->movlps(xmmA, anyptr_gpB); 1304 e->movlps(anyptr_gpA, xmmB); 1305 e->movntps(anyptr_gpA, xmmB); 1306 e->movss(xmmA, anyptr_gpB); 1307 e->movss(anyptr_gpA, xmmB); 1308 e->movups(xmmA, xmmB); 1309 e->movups(xmmA, anyptr_gpB); 1310 e->movups(anyptr_gpA, xmmB); 1311 e->mulps(xmmA, xmmB); 1312 e->mulps(xmmA, anyptr_gpB); 1313 e->mulss(xmmA, xmmB); 1314 e->mulss(xmmA, anyptr_gpB); 1315 e->orps(xmmA, xmmB); 1316 e->orps(xmmA, anyptr_gpB); 1317 e->pavgb(mmA, mmB); 1318 e->pavgb(mmA, anyptr_gpB); 1319 e->pavgw(mmA, mmB); 1320 e->pavgw(mmA, anyptr_gpB); 1321 e->pextrw(gdA, mmB, 0); 1322 e->pextrw(gzA, mmB, 0); 1323 e->pinsrw(mmA, gdB, 0); 1324 e->pinsrw(mmA, gzB, 0); 1325 e->pinsrw(mmA, anyptr_gpB, 0); 1326 e->pmaxsw(mmA, mmB); 1327 e->pmaxsw(mmA, anyptr_gpB); 1328 e->pmaxub(mmA, mmB); 1329 e->pmaxub(mmA, anyptr_gpB); 1330 e->pminsw(mmA, mmB); 1331 e->pminsw(mmA, anyptr_gpB); 1332 e->pminub(mmA, mmB); 1333 e->pminub(mmA, anyptr_gpB); 1334 e->pmovmskb(gdA, mmB); 1335 e->pmovmskb(gzA, mmB); 1336 e->pmulhuw(mmA, mmB); 1337 e->pmulhuw(mmA, anyptr_gpB); 1338 e->psadbw(mmA, mmB); 1339 e->psadbw(mmA, anyptr_gpB); 1340 e->pshufw(mmA, mmB, 0); 1341 e->pshufw(mmA, anyptr_gpB, 0); 1342 e->rcpps(xmmA, xmmB); 1343 e->rcpps(xmmA, anyptr_gpB); 1344 e->rcpss(xmmA, xmmB); 1345 e->rcpss(xmmA, anyptr_gpB); 1346 e->psadbw(xmmA, xmmB); 1347 e->psadbw(xmmA, anyptr_gpB); 1348 e->rsqrtps(xmmA, xmmB); 1349 e->rsqrtps(xmmA, anyptr_gpB); 1350 e->rsqrtss(xmmA, xmmB); 1351 e->rsqrtss(xmmA, anyptr_gpB); 1352 e->sfence(); 1353 e->shufps(xmmA, xmmB, 0); 1354 e->shufps(xmmA, anyptr_gpB, 0); 1355 e->sqrtps(xmmA, xmmB); 1356 e->sqrtps(xmmA, anyptr_gpB); 1357 e->sqrtss(xmmA, xmmB); 1358 e->sqrtss(xmmA, anyptr_gpB); 1359 e->stmxcsr(anyptr_gpA); 1360 e->subps(xmmA, xmmB); 1361 e->subps(xmmA, anyptr_gpB); 1362 e->subss(xmmA, xmmB); 1363 e->subss(xmmA, anyptr_gpB); 1364 e->ucomiss(xmmA, xmmB); 1365 e->ucomiss(xmmA, anyptr_gpB); 1366 e->unpckhps(xmmA, xmmB); 1367 e->unpckhps(xmmA, anyptr_gpB); 1368 e->unpcklps(xmmA, xmmB); 1369 e->unpcklps(xmmA, anyptr_gpB); 1370 e->xorps(xmmA, xmmB); 1371 e->xorps(xmmA, anyptr_gpB); 1372 1373 // SSE2. 1374 e->nop(); 1375 1376 e->addpd(xmmA, xmmB); 1377 e->addpd(xmmA, anyptr_gpB); 1378 e->addsd(xmmA, xmmB); 1379 e->addsd(xmmA, anyptr_gpB); 1380 e->andnpd(xmmA, xmmB); 1381 e->andnpd(xmmA, anyptr_gpB); 1382 e->andpd(xmmA, xmmB); 1383 e->andpd(xmmA, anyptr_gpB); 1384 e->cmppd(xmmA, xmmB, 0); 1385 e->cmppd(xmmA, anyptr_gpB, 0); 1386 e->cmpsd(xmmA, xmmB, 0); 1387 e->cmpsd(xmmA, anyptr_gpB, 0); 1388 e->comisd(xmmA, xmmB); 1389 e->comisd(xmmA, anyptr_gpB); 1390 e->cvtdq2pd(xmmA, xmmB); 1391 e->cvtdq2pd(xmmA, anyptr_gpB); 1392 e->cvtdq2ps(xmmA, xmmB); 1393 e->cvtdq2ps(xmmA, anyptr_gpB); 1394 e->cvtpd2dq(xmmA, xmmB); 1395 e->cvtpd2dq(xmmA, anyptr_gpB); 1396 e->cvtpd2pi(mmA, xmmB); 1397 e->cvtpd2pi(mmA, anyptr_gpB); 1398 e->cvtpd2ps(xmmA, xmmB); 1399 e->cvtpd2ps(xmmA, anyptr_gpB); 1400 e->cvtpi2pd(xmmA, mmB); 1401 e->cvtpi2pd(xmmA, anyptr_gpB); 1402 e->cvtps2dq(xmmA, xmmB); 1403 e->cvtps2dq(xmmA, anyptr_gpB); 1404 e->cvtps2pd(xmmA, xmmB); 1405 e->cvtps2pd(xmmA, anyptr_gpB); 1406 e->cvtsd2si(gdA, xmmB); 1407 e->cvtsd2si(gzA, xmmB); 1408 e->cvtsd2si(gdA, anyptr_gpB); 1409 e->cvtsd2si(gzA, anyptr_gpB); 1410 e->cvtsd2ss(xmmA, xmmB); 1411 e->cvtsd2ss(xmmA, anyptr_gpB); 1412 e->cvtsi2sd(xmmA, gdB); 1413 e->cvtsi2sd(xmmA, gzB); 1414 e->cvtsi2sd(xmmA, anyptr_gpB); 1415 e->cvtss2sd(xmmA, xmmB); 1416 e->cvtss2sd(xmmA, anyptr_gpB); 1417 e->cvtss2si(gdA, xmmB); 1418 e->cvtss2si(gzA, xmmB); 1419 e->cvtss2si(gdA, anyptr_gpB); 1420 e->cvtss2si(gzA, anyptr_gpB); 1421 e->cvttpd2pi(mmA, xmmB); 1422 e->cvttpd2pi(mmA, anyptr_gpB); 1423 e->cvttpd2dq(xmmA, xmmB); 1424 e->cvttpd2dq(xmmA, anyptr_gpB); 1425 e->cvttps2dq(xmmA, xmmB); 1426 e->cvttps2dq(xmmA, anyptr_gpB); 1427 e->cvttsd2si(gdA, xmmB); 1428 e->cvttsd2si(gzA, xmmB); 1429 e->cvttsd2si(gdA, anyptr_gpB); 1430 e->cvttsd2si(gzA, anyptr_gpB); 1431 e->divpd(xmmA, xmmB); 1432 e->divpd(xmmA, anyptr_gpB); 1433 e->divsd(xmmA, xmmB); 1434 e->divsd(xmmA, anyptr_gpB); 1435 e->lfence(); 1436 e->maskmovdqu(xmmA, xmmB); // Implicit xmmA, xmmB, <ds:[EDI|RDI]> 1437 e->maskmovdqu(xmmA, xmmB, ptr(e->zdi())); // Explicit xmmA, xmmB, <ds:[EDI|RDI]> 1438 e->maxpd(xmmA, xmmB); 1439 e->maxpd(xmmA, anyptr_gpB); 1440 e->maxsd(xmmA, xmmB); 1441 e->maxsd(xmmA, anyptr_gpB); 1442 e->mfence(); 1443 e->minpd(xmmA, xmmB); 1444 e->minpd(xmmA, anyptr_gpB); 1445 e->minsd(xmmA, xmmB); 1446 e->minsd(xmmA, anyptr_gpB); 1447 e->movdqa(xmmA, xmmB); 1448 e->movdqa(xmmA, anyptr_gpB); 1449 e->movdqa(anyptr_gpA, xmmB); 1450 e->movdqu(xmmA, xmmB); 1451 e->movdqu(xmmA, anyptr_gpB); 1452 e->movdqu(anyptr_gpA, xmmB); 1453 e->movmskps(gdA, xmmB); 1454 e->movmskps(gzA, xmmB); 1455 e->movmskpd(gdA, xmmB); 1456 e->movmskpd(gzA, xmmB); 1457 e->movsd(xmmA, xmmB); 1458 e->movsd(xmmA, anyptr_gpB); 1459 e->movsd(anyptr_gpA, xmmB); 1460 e->movapd(xmmA, anyptr_gpB); 1461 e->movapd(anyptr_gpA, xmmB); 1462 e->movdq2q(mmA, xmmB); 1463 e->movq2dq(xmmA, mmB); 1464 e->movhpd(xmmA, anyptr_gpB); 1465 e->movhpd(anyptr_gpA, xmmB); 1466 e->movlpd(xmmA, anyptr_gpB); 1467 e->movlpd(anyptr_gpA, xmmB); 1468 e->movntdq(anyptr_gpA, xmmB); 1469 e->movnti(anyptr_gpA, gdB); 1470 e->movnti(anyptr_gpA, gzB); 1471 e->movntpd(anyptr_gpA, xmmB); 1472 e->movupd(xmmA, anyptr_gpB); 1473 e->movupd(anyptr_gpA, xmmB); 1474 e->mulpd(xmmA, xmmB); 1475 e->mulpd(xmmA, anyptr_gpB); 1476 e->mulsd(xmmA, xmmB); 1477 e->mulsd(xmmA, anyptr_gpB); 1478 e->orpd(xmmA, xmmB); 1479 e->orpd(xmmA, anyptr_gpB); 1480 e->packsswb(xmmA, xmmB); 1481 e->packsswb(xmmA, anyptr_gpB); 1482 e->packssdw(xmmA, xmmB); 1483 e->packssdw(xmmA, anyptr_gpB); 1484 e->packuswb(xmmA, xmmB); 1485 e->packuswb(xmmA, anyptr_gpB); 1486 e->paddb(xmmA, xmmB); 1487 e->paddb(xmmA, anyptr_gpB); 1488 e->paddw(xmmA, xmmB); 1489 e->paddw(xmmA, anyptr_gpB); 1490 e->paddd(xmmA, xmmB); 1491 e->paddd(xmmA, anyptr_gpB); 1492 e->paddq(mmA, mmB); 1493 e->paddq(mmA, anyptr_gpB); 1494 e->paddq(xmmA, xmmB); 1495 e->paddq(xmmA, anyptr_gpB); 1496 e->paddsb(xmmA, xmmB); 1497 e->paddsb(xmmA, anyptr_gpB); 1498 e->paddsw(xmmA, xmmB); 1499 e->paddsw(xmmA, anyptr_gpB); 1500 e->paddusb(xmmA, xmmB); 1501 e->paddusb(xmmA, anyptr_gpB); 1502 e->paddusw(xmmA, xmmB); 1503 e->paddusw(xmmA, anyptr_gpB); 1504 e->pand(xmmA, xmmB); 1505 e->pand(xmmA, anyptr_gpB); 1506 e->pandn(xmmA, xmmB); 1507 e->pandn(xmmA, anyptr_gpB); 1508 e->pause(); 1509 e->pavgb(xmmA, xmmB); 1510 e->pavgb(xmmA, anyptr_gpB); 1511 e->pavgw(xmmA, xmmB); 1512 e->pavgw(xmmA, anyptr_gpB); 1513 e->pcmpeqb(xmmA, xmmB); 1514 e->pcmpeqb(xmmA, anyptr_gpB); 1515 e->pcmpeqw(xmmA, xmmB); 1516 e->pcmpeqw(xmmA, anyptr_gpB); 1517 e->pcmpeqd(xmmA, xmmB); 1518 e->pcmpeqd(xmmA, anyptr_gpB); 1519 e->pcmpgtb(xmmA, xmmB); 1520 e->pcmpgtb(xmmA, anyptr_gpB); 1521 e->pcmpgtw(xmmA, xmmB); 1522 e->pcmpgtw(xmmA, anyptr_gpB); 1523 e->pcmpgtd(xmmA, xmmB); 1524 e->pcmpgtd(xmmA, anyptr_gpB); 1525 e->pmaxsw(xmmA, xmmB); 1526 e->pmaxsw(xmmA, anyptr_gpB); 1527 e->pmaxub(xmmA, xmmB); 1528 e->pmaxub(xmmA, anyptr_gpB); 1529 e->pminsw(xmmA, xmmB); 1530 e->pminsw(xmmA, anyptr_gpB); 1531 e->pminub(xmmA, xmmB); 1532 e->pminub(xmmA, anyptr_gpB); 1533 e->pmovmskb(gdA, xmmB); 1534 e->pmovmskb(gzA, xmmB); 1535 e->pmulhw(xmmA, xmmB); 1536 e->pmulhw(xmmA, anyptr_gpB); 1537 e->pmulhuw(xmmA, xmmB); 1538 e->pmulhuw(xmmA, anyptr_gpB); 1539 e->pmullw(xmmA, xmmB); 1540 e->pmullw(xmmA, anyptr_gpB); 1541 e->pmuludq(mmA, mmB); 1542 e->pmuludq(mmA, anyptr_gpB); 1543 e->pmuludq(xmmA, xmmB); 1544 e->pmuludq(xmmA, anyptr_gpB); 1545 e->por(xmmA, xmmB); 1546 e->por(xmmA, anyptr_gpB); 1547 e->pslld(xmmA, xmmB); 1548 e->pslld(xmmA, anyptr_gpB); 1549 e->pslld(xmmA, 0); 1550 e->psllq(xmmA, xmmB); 1551 e->psllq(xmmA, anyptr_gpB); 1552 e->psllq(xmmA, 0); 1553 e->psllw(xmmA, xmmB); 1554 e->psllw(xmmA, anyptr_gpB); 1555 e->psllw(xmmA, 0); 1556 e->pslldq(xmmA, 0); 1557 e->psrad(xmmA, xmmB); 1558 e->psrad(xmmA, anyptr_gpB); 1559 e->psrad(xmmA, 0); 1560 e->psraw(xmmA, xmmB); 1561 e->psraw(xmmA, anyptr_gpB); 1562 e->psraw(xmmA, 0); 1563 e->psubb(xmmA, xmmB); 1564 e->psubb(xmmA, anyptr_gpB); 1565 e->psubw(xmmA, xmmB); 1566 e->psubw(xmmA, anyptr_gpB); 1567 e->psubd(xmmA, xmmB); 1568 e->psubd(xmmA, anyptr_gpB); 1569 e->psubq(mmA, mmB); 1570 e->psubq(mmA, anyptr_gpB); 1571 e->psubq(xmmA, xmmB); 1572 e->psubq(xmmA, anyptr_gpB); 1573 e->pmaddwd(xmmA, xmmB); 1574 e->pmaddwd(xmmA, anyptr_gpB); 1575 e->pshufd(xmmA, xmmB, 0); 1576 e->pshufd(xmmA, anyptr_gpB, 0); 1577 e->pshufhw(xmmA, xmmB, 0); 1578 e->pshufhw(xmmA, anyptr_gpB, 0); 1579 e->pshuflw(xmmA, xmmB, 0); 1580 e->pshuflw(xmmA, anyptr_gpB, 0); 1581 e->psrld(xmmA, xmmB); 1582 e->psrld(xmmA, anyptr_gpB); 1583 e->psrld(xmmA, 0); 1584 e->psrlq(xmmA, xmmB); 1585 e->psrlq(xmmA, anyptr_gpB); 1586 e->psrlq(xmmA, 0); 1587 e->psrldq(xmmA, 0); 1588 e->psrlw(xmmA, xmmB); 1589 e->psrlw(xmmA, anyptr_gpB); 1590 e->psrlw(xmmA, 0); 1591 e->psubsb(xmmA, xmmB); 1592 e->psubsb(xmmA, anyptr_gpB); 1593 e->psubsw(xmmA, xmmB); 1594 e->psubsw(xmmA, anyptr_gpB); 1595 e->psubusb(xmmA, xmmB); 1596 e->psubusb(xmmA, anyptr_gpB); 1597 e->psubusw(xmmA, xmmB); 1598 e->psubusw(xmmA, anyptr_gpB); 1599 e->punpckhbw(xmmA, xmmB); 1600 e->punpckhbw(xmmA, anyptr_gpB); 1601 e->punpckhwd(xmmA, xmmB); 1602 e->punpckhwd(xmmA, anyptr_gpB); 1603 e->punpckhdq(xmmA, xmmB); 1604 e->punpckhdq(xmmA, anyptr_gpB); 1605 e->punpckhqdq(xmmA, xmmB); 1606 e->punpckhqdq(xmmA, anyptr_gpB); 1607 e->punpcklbw(xmmA, xmmB); 1608 e->punpcklbw(xmmA, anyptr_gpB); 1609 e->punpcklwd(xmmA, xmmB); 1610 e->punpcklwd(xmmA, anyptr_gpB); 1611 e->punpckldq(xmmA, xmmB); 1612 e->punpckldq(xmmA, anyptr_gpB); 1613 e->punpcklqdq(xmmA, xmmB); 1614 e->punpcklqdq(xmmA, anyptr_gpB); 1615 e->pxor(xmmA, xmmB); 1616 e->pxor(xmmA, anyptr_gpB); 1617 e->sqrtpd(xmmA, xmmB); 1618 e->sqrtpd(xmmA, anyptr_gpB); 1619 e->sqrtsd(xmmA, xmmB); 1620 e->sqrtsd(xmmA, anyptr_gpB); 1621 e->subpd(xmmA, xmmB); 1622 e->subpd(xmmA, anyptr_gpB); 1623 e->subsd(xmmA, xmmB); 1624 e->subsd(xmmA, anyptr_gpB); 1625 e->ucomisd(xmmA, xmmB); 1626 e->ucomisd(xmmA, anyptr_gpB); 1627 e->unpckhpd(xmmA, xmmB); 1628 e->unpckhpd(xmmA, anyptr_gpB); 1629 e->unpcklpd(xmmA, xmmB); 1630 e->unpcklpd(xmmA, anyptr_gpB); 1631 e->xorpd(xmmA, xmmB); 1632 e->xorpd(xmmA, anyptr_gpB); 1633 1634 // SSE3. 1635 e->nop(); 1636 1637 e->addsubpd(xmmA, xmmB); 1638 e->addsubpd(xmmA, anyptr_gpB); 1639 e->addsubps(xmmA, xmmB); 1640 e->addsubps(xmmA, anyptr_gpB); 1641 e->fisttp(dword_ptr(gzA)); 1642 e->haddpd(xmmA, xmmB); 1643 e->haddpd(xmmA, anyptr_gpB); 1644 e->haddps(xmmA, xmmB); 1645 e->haddps(xmmA, anyptr_gpB); 1646 e->hsubpd(xmmA, xmmB); 1647 e->hsubpd(xmmA, anyptr_gpB); 1648 e->hsubps(xmmA, xmmB); 1649 e->hsubps(xmmA, anyptr_gpB); 1650 e->lddqu(xmmA, anyptr_gpB); 1651 e->movddup(xmmA, xmmB); 1652 e->movddup(xmmA, anyptr_gpB); 1653 e->movshdup(xmmA, xmmB); 1654 e->movshdup(xmmA, anyptr_gpB); 1655 e->movsldup(xmmA, xmmB); 1656 e->movsldup(xmmA, anyptr_gpB); 1657 1658 // SSSE3. 1659 e->nop(); 1660 1661 e->psignb(mmA, mmB); 1662 e->psignb(mmA, anyptr_gpB); 1663 e->psignb(xmmA, xmmB); 1664 e->psignb(xmmA, anyptr_gpB); 1665 e->psignw(mmA, mmB); 1666 e->psignw(mmA, anyptr_gpB); 1667 e->psignw(xmmA, xmmB); 1668 e->psignw(xmmA, anyptr_gpB); 1669 e->psignd(mmA, mmB); 1670 e->psignd(mmA, anyptr_gpB); 1671 e->psignd(xmmA, xmmB); 1672 e->psignd(xmmA, anyptr_gpB); 1673 e->phaddw(mmA, mmB); 1674 e->phaddw(mmA, anyptr_gpB); 1675 e->phaddw(xmmA, xmmB); 1676 e->phaddw(xmmA, anyptr_gpB); 1677 e->phaddd(mmA, mmB); 1678 e->phaddd(mmA, anyptr_gpB); 1679 e->phaddd(xmmA, xmmB); 1680 e->phaddd(xmmA, anyptr_gpB); 1681 e->phaddsw(mmA, mmB); 1682 e->phaddsw(mmA, anyptr_gpB); 1683 e->phaddsw(xmmA, xmmB); 1684 e->phaddsw(xmmA, anyptr_gpB); 1685 e->phsubw(mmA, mmB); 1686 e->phsubw(mmA, anyptr_gpB); 1687 e->phsubw(xmmA, xmmB); 1688 e->phsubw(xmmA, anyptr_gpB); 1689 e->phsubd(mmA, mmB); 1690 e->phsubd(mmA, anyptr_gpB); 1691 e->phsubd(xmmA, xmmB); 1692 e->phsubd(xmmA, anyptr_gpB); 1693 e->phsubsw(mmA, mmB); 1694 e->phsubsw(mmA, anyptr_gpB); 1695 e->phsubsw(xmmA, xmmB); 1696 e->phsubsw(xmmA, anyptr_gpB); 1697 e->pmaddubsw(mmA, mmB); 1698 e->pmaddubsw(mmA, anyptr_gpB); 1699 e->pmaddubsw(xmmA, xmmB); 1700 e->pmaddubsw(xmmA, anyptr_gpB); 1701 e->pabsb(mmA, mmB); 1702 e->pabsb(mmA, anyptr_gpB); 1703 e->pabsb(xmmA, xmmB); 1704 e->pabsb(xmmA, anyptr_gpB); 1705 e->pabsw(mmA, mmB); 1706 e->pabsw(mmA, anyptr_gpB); 1707 e->pabsw(xmmA, xmmB); 1708 e->pabsw(xmmA, anyptr_gpB); 1709 e->pabsd(mmA, mmB); 1710 e->pabsd(mmA, anyptr_gpB); 1711 e->pabsd(xmmA, xmmB); 1712 e->pabsd(xmmA, anyptr_gpB); 1713 e->pmulhrsw(mmA, mmB); 1714 e->pmulhrsw(mmA, anyptr_gpB); 1715 e->pmulhrsw(xmmA, xmmB); 1716 e->pmulhrsw(xmmA, anyptr_gpB); 1717 e->pshufb(mmA, mmB); 1718 e->pshufb(mmA, anyptr_gpB); 1719 e->pshufb(xmmA, xmmB); 1720 e->pshufb(xmmA, anyptr_gpB); 1721 e->palignr(mmA, mmB, 0); 1722 e->palignr(mmA, anyptr_gpB, 0); 1723 e->palignr(xmmA, xmmB, 0); 1724 e->palignr(xmmA, anyptr_gpB, 0); 1725 1726 // SSE4.1. 1727 e->nop(); 1728 1729 e->blendpd(xmmA, xmmB, 0); 1730 e->blendpd(xmmA, anyptr_gpB, 0); 1731 e->blendps(xmmA, xmmB, 0); 1732 e->blendps(xmmA, anyptr_gpB, 0); 1733 e->blendvpd(xmmA, xmmB); // Implicit xmmA, xmmB, <XMM0> 1734 e->blendvpd(xmmA, xmmB, xmm0); // Explicit xmmA, xmmB, <XMM0> 1735 e->blendvpd(xmmA, anyptr_gpB); // Implicit xmmA, mem , <XMM0> 1736 e->blendvpd(xmmA, anyptr_gpB, xmm0); // Explicit xmmA, mem , <XMM0> 1737 e->blendvps(xmmA, xmmB); // Implicit xmmA, xmmB, <XMM0> 1738 e->blendvps(xmmA, xmmB, xmm0); // Explicit xmmA, xmmB, <XMM0> 1739 e->blendvps(xmmA, anyptr_gpB); // Implicit xmmA, mem , <XMM0> 1740 e->blendvps(xmmA, anyptr_gpB, xmm0); // Explicit xmmA, mem , <XMM0> 1741 1742 e->dppd(xmmA, xmmB, 0); 1743 e->dppd(xmmA, anyptr_gpB, 0); 1744 e->dpps(xmmA, xmmB, 0); 1745 e->dpps(xmmA, anyptr_gpB, 0); 1746 e->extractps(gdA, xmmB, 0); 1747 e->extractps(gzA, xmmB, 0); 1748 e->extractps(anyptr_gpA, xmmB, 0); 1749 e->insertps(xmmA, xmmB, 0); 1750 e->insertps(xmmA, anyptr_gpB, 0); 1751 e->movntdqa(xmmA, anyptr_gpB); 1752 e->mpsadbw(xmmA, xmmB, 0); 1753 e->mpsadbw(xmmA, anyptr_gpB, 0); 1754 e->packusdw(xmmA, xmmB); 1755 e->packusdw(xmmA, anyptr_gpB); 1756 e->pblendvb(xmmA, xmmB); // Implicit xmmA, xmmB, <XMM0> 1757 e->pblendvb(xmmA, xmmB, xmm0); // Explicit xmmA, xmmB, <XMM0> 1758 e->pblendvb(xmmA, anyptr_gpB); // Implicit xmmA, mem, <XMM0> 1759 e->pblendvb(xmmA, anyptr_gpB, xmm0); // Implicit xmmA, mem, <XMM0> 1760 e->pblendw(xmmA, xmmB, 0); 1761 e->pblendw(xmmA, anyptr_gpB, 0); 1762 e->pcmpeqq(xmmA, xmmB); 1763 e->pcmpeqq(xmmA, anyptr_gpB); 1764 e->pextrb(gdA, xmmB, 0); 1765 e->pextrb(gzA, xmmB, 0); 1766 e->pextrb(anyptr_gpA, xmmB, 0); 1767 e->pextrd(gdA, xmmB, 0); 1768 e->pextrd(gzA, xmmB, 0); 1769 e->pextrd(anyptr_gpA, xmmB, 0); 1770 if (isX64) e->pextrq(gzA, xmmB, 0); 1771 if (isX64) e->pextrq(anyptr_gpA, xmmB, 0); 1772 e->pextrw(gdA, xmmB, 0); 1773 e->pextrw(gzA, xmmB, 0); 1774 e->pextrw(anyptr_gpA, xmmB, 0); 1775 e->phminposuw(xmmA, xmmB); 1776 e->phminposuw(xmmA, anyptr_gpB); 1777 e->pinsrb(xmmA, gdB, 0); 1778 e->pinsrb(xmmA, gzB, 0); 1779 e->pinsrb(xmmA, anyptr_gpB, 0); 1780 e->pinsrd(xmmA, gdB, 0); 1781 e->pinsrd(xmmA, gzB, 0); 1782 e->pinsrd(xmmA, anyptr_gpB, 0); 1783 e->pinsrw(xmmA, gdB, 0); 1784 e->pinsrw(xmmA, gzB, 0); 1785 e->pinsrw(xmmA, anyptr_gpB, 0); 1786 e->pmaxuw(xmmA, xmmB); 1787 e->pmaxuw(xmmA, anyptr_gpB); 1788 e->pmaxsb(xmmA, xmmB); 1789 e->pmaxsb(xmmA, anyptr_gpB); 1790 e->pmaxsd(xmmA, xmmB); 1791 e->pmaxsd(xmmA, anyptr_gpB); 1792 e->pmaxud(xmmA, xmmB); 1793 e->pmaxud(xmmA, anyptr_gpB); 1794 e->pminsb(xmmA, xmmB); 1795 e->pminsb(xmmA, anyptr_gpB); 1796 e->pminuw(xmmA, xmmB); 1797 e->pminuw(xmmA, anyptr_gpB); 1798 e->pminud(xmmA, xmmB); 1799 e->pminud(xmmA, anyptr_gpB); 1800 e->pminsd(xmmA, xmmB); 1801 e->pminsd(xmmA, anyptr_gpB); 1802 e->pmovsxbw(xmmA, xmmB); 1803 e->pmovsxbw(xmmA, anyptr_gpB); 1804 e->pmovsxbd(xmmA, xmmB); 1805 e->pmovsxbd(xmmA, anyptr_gpB); 1806 e->pmovsxbq(xmmA, xmmB); 1807 e->pmovsxbq(xmmA, anyptr_gpB); 1808 e->pmovsxwd(xmmA, xmmB); 1809 e->pmovsxwd(xmmA, anyptr_gpB); 1810 e->pmovsxwq(xmmA, xmmB); 1811 e->pmovsxwq(xmmA, anyptr_gpB); 1812 e->pmovsxdq(xmmA, xmmB); 1813 e->pmovsxdq(xmmA, anyptr_gpB); 1814 e->pmovzxbw(xmmA, xmmB); 1815 e->pmovzxbw(xmmA, anyptr_gpB); 1816 e->pmovzxbd(xmmA, xmmB); 1817 e->pmovzxbd(xmmA, anyptr_gpB); 1818 e->pmovzxbq(xmmA, xmmB); 1819 e->pmovzxbq(xmmA, anyptr_gpB); 1820 e->pmovzxwd(xmmA, xmmB); 1821 e->pmovzxwd(xmmA, anyptr_gpB); 1822 e->pmovzxwq(xmmA, xmmB); 1823 e->pmovzxwq(xmmA, anyptr_gpB); 1824 e->pmovzxdq(xmmA, xmmB); 1825 e->pmovzxdq(xmmA, anyptr_gpB); 1826 e->pmuldq(xmmA, xmmB); 1827 e->pmuldq(xmmA, anyptr_gpB); 1828 e->pmulld(xmmA, xmmB); 1829 e->pmulld(xmmA, anyptr_gpB); 1830 e->ptest(xmmA, xmmB); 1831 e->ptest(xmmA, anyptr_gpB); 1832 e->roundps(xmmA, xmmB, 0); 1833 e->roundps(xmmA, anyptr_gpB, 0); 1834 e->roundss(xmmA, xmmB, 0); 1835 e->roundss(xmmA, anyptr_gpB, 0); 1836 e->roundpd(xmmA, xmmB, 0); 1837 e->roundpd(xmmA, anyptr_gpB, 0); 1838 e->roundsd(xmmA, xmmB, 0); 1839 e->roundsd(xmmA, anyptr_gpB, 0); 1840 1841 // SSE4.2. 1842 e->nop(); 1843 1844 e->pcmpestri(xmmA, xmmB , imm(0)); // Implicit xmmA, xmmB, imm, <ECX>, <EAX>, <EDX> 1845 e->pcmpestri(xmmA, xmmB , imm(0), ecx, eax, edx); // Explicit xmmA, xmmB, imm, <ECX>, <EAX>, <EDX> 1846 e->pcmpestri(xmmA, anyptr_gpB, imm(0)); // Implicit xmmA, mem , imm, <ECX>, <EAX>, <EDX> 1847 e->pcmpestri(xmmA, anyptr_gpB, imm(0), ecx, eax, edx); // Explicit xmmA, mem , imm, <ECX>, <EAX>, <EDX> 1848 e->pcmpestrm(xmmA, xmmB , imm(0)); // Implicit xmmA, xmmB, imm, <XMM0>, <EAX>, <EDX> 1849 e->pcmpestrm(xmmA, xmmB , imm(0), xmm0, eax, edx); // Explicit xmmA, xmmB, imm, <XMM0>, <EAX>, <EDX> 1850 e->pcmpestrm(xmmA, anyptr_gpB, imm(0)); // Implicit xmmA, mem , imm, <XMM0>, <EAX>, <EDX> 1851 e->pcmpestrm(xmmA, anyptr_gpB, imm(0), xmm0, eax, edx); // Explicit xmmA, mem , imm, <XMM0>, <EAX>, <EDX> 1852 e->pcmpistri(xmmA, xmmB , imm(0)); // Implicit xmmA, xmmB, imm, <ECX> 1853 e->pcmpistri(xmmA, xmmB , imm(0), ecx); // Explicit xmmA, xmmB, imm, <ECX> 1854 e->pcmpistri(xmmA, anyptr_gpB, imm(0)); // Implicit xmmA, mem , imm, <ECX> 1855 e->pcmpistri(xmmA, anyptr_gpB, imm(0), ecx); // Explicit xmmA, mem , imm, <ECX> 1856 e->pcmpistrm(xmmA, xmmB , imm(0)); // Implicit xmmA, xmmB, imm, <XMM0> 1857 e->pcmpistrm(xmmA, xmmB , imm(0), xmm0); // Explicit xmmA, xmmB, imm, <XMM0> 1858 e->pcmpistrm(xmmA, anyptr_gpB, imm(0)); // Implicit xmmA, mem , imm, <XMM0> 1859 e->pcmpistrm(xmmA, anyptr_gpB, imm(0), xmm0); // Explicit xmmA, mem , imm, <XMM0> 1860 1861 e->pcmpgtq(xmmA, xmmB); 1862 e->pcmpgtq(xmmA, anyptr_gpB); 1863 1864 // SSE4A. 1865 e->nop(); 1866 1867 e->extrq(xmmA, xmmB); 1868 e->extrq(xmmA, 0x1, 0x2); 1869 e->extrq(xmmB, 0x1, 0x2); 1870 e->insertq(xmmA, xmmB); 1871 e->insertq(xmmA, xmmB, 0x1, 0x2); 1872 e->movntsd(anyptr_gpA, xmmB); 1873 e->movntss(anyptr_gpA, xmmB); 1874 1875 // AESNI. 1876 e->nop(); 1877 1878 e->aesdec(xmmA, xmmB); 1879 e->aesdec(xmmA, anyptr_gpB); 1880 e->aesdeclast(xmmA, xmmB); 1881 e->aesdeclast(xmmA, anyptr_gpB); 1882 e->aesenc(xmmA, xmmB); 1883 e->aesenc(xmmA, anyptr_gpB); 1884 e->aesenclast(xmmA, xmmB); 1885 e->aesenclast(xmmA, anyptr_gpB); 1886 e->aesimc(xmmA, xmmB); 1887 e->aesimc(xmmA, anyptr_gpB); 1888 e->aeskeygenassist(xmmA, xmmB, 0); 1889 e->aeskeygenassist(xmmA, anyptr_gpB, 0); 1890 1891 // SHA. 1892 e->nop(); 1893 1894 e->sha1msg1(xmmA, xmmB); 1895 e->sha1msg1(xmmA, anyptr_gpB); 1896 e->sha1msg2(xmmA, xmmB); 1897 e->sha1msg2(xmmA, anyptr_gpB); 1898 e->sha1nexte(xmmA, xmmB); 1899 e->sha1nexte(xmmA, anyptr_gpB); 1900 e->sha1rnds4(xmmA, xmmB, 0); 1901 e->sha1rnds4(xmmA, anyptr_gpB, 0); 1902 e->sha256msg1(xmmA, xmmB); 1903 e->sha256msg1(xmmA, anyptr_gpB); 1904 e->sha256msg2(xmmA, xmmB); 1905 e->sha256msg2(xmmA, anyptr_gpB); 1906 e->sha256rnds2(xmmA, xmmB); // Implicit xmmA, xmmB, <XMM0> 1907 e->sha256rnds2(xmmA, xmmB, xmm0); // Explicit xmmA, xmmB, <XMM0> 1908 e->sha256rnds2(xmmA, anyptr_gpB); // Implicit xmmA, mem, <XMM0> 1909 e->sha256rnds2(xmmA, anyptr_gpB, xmm0); // Explicit xmmA, mem, <XMM0> 1910 1911 // PCLMULQDQ. 1912 e->nop(); 1913 1914 e->pclmulqdq(xmmA, xmmB, 0); 1915 e->pclmulqdq(xmmA, anyptr_gpB, 0); 1916 1917 // AVX. 1918 e->nop(); 1919 1920 e->vaddpd(xmmA, xmmB, xmmC); 1921 e->vaddpd(xmmA, xmmB, anyptr_gpC); 1922 e->vaddpd(ymmA, ymmB, ymmC); 1923 e->vaddpd(ymmA, ymmB, anyptr_gpC); 1924 e->vaddps(xmmA, xmmB, xmmC); 1925 e->vaddps(xmmA, xmmB, anyptr_gpC); 1926 e->vaddps(ymmA, ymmB, ymmC); 1927 e->vaddps(ymmA, ymmB, anyptr_gpC); 1928 e->vaddsd(xmmA, xmmB, xmmC); 1929 e->vaddsd(xmmA, xmmB, anyptr_gpC); 1930 e->vaddss(xmmA, xmmB, xmmC); 1931 e->vaddss(xmmA, xmmB, anyptr_gpC); 1932 e->vaddsubpd(xmmA, xmmB, xmmC); 1933 e->vaddsubpd(xmmA, xmmB, anyptr_gpC); 1934 e->vaddsubpd(ymmA, ymmB, ymmC); 1935 e->vaddsubpd(ymmA, ymmB, anyptr_gpC); 1936 e->vaddsubps(xmmA, xmmB, xmmC); 1937 e->vaddsubps(xmmA, xmmB, anyptr_gpC); 1938 e->vaddsubps(ymmA, ymmB, ymmC); 1939 e->vaddsubps(ymmA, ymmB, anyptr_gpC); 1940 e->vandpd(xmmA, xmmB, xmmC); 1941 e->vandpd(xmmA, xmmB, anyptr_gpC); 1942 e->vandpd(ymmA, ymmB, ymmC); 1943 e->vandpd(ymmA, ymmB, anyptr_gpC); 1944 e->vandps(xmmA, xmmB, xmmC); 1945 e->vandps(xmmA, xmmB, anyptr_gpC); 1946 e->vandps(ymmA, ymmB, ymmC); 1947 e->vandps(ymmA, ymmB, anyptr_gpC); 1948 e->vandnpd(xmmA, xmmB, xmmC); 1949 e->vandnpd(xmmA, xmmB, anyptr_gpC); 1950 e->vandnpd(ymmA, ymmB, ymmC); 1951 e->vandnpd(ymmA, ymmB, anyptr_gpC); 1952 e->vandnps(xmmA, xmmB, xmmC); 1953 e->vandnps(xmmA, xmmB, anyptr_gpC); 1954 e->vandnps(ymmA, ymmB, ymmC); 1955 e->vandnps(ymmA, ymmB, anyptr_gpC); 1956 e->vblendpd(xmmA, xmmB, xmmC, 0); 1957 e->vblendpd(xmmA, xmmB, anyptr_gpC, 0); 1958 e->vblendpd(ymmA, ymmB, ymmC, 0); 1959 e->vblendpd(ymmA, ymmB, anyptr_gpC, 0); 1960 e->vblendps(xmmA, xmmB, xmmC, 0); 1961 e->vblendps(xmmA, xmmB, anyptr_gpC, 0); 1962 e->vblendps(ymmA, ymmB, ymmC, 0); 1963 e->vblendps(ymmA, ymmB, anyptr_gpC, 0); 1964 e->vblendvpd(xmmA, xmmB, xmmC, xmmD); 1965 e->vblendvpd(xmmA, xmmB, anyptr_gpC, xmmD); 1966 e->vblendvpd(ymmA, ymmB, ymmC, ymmD); 1967 e->vblendvpd(ymmA, ymmB, anyptr_gpC, ymmD); 1968 e->vbroadcastf128(ymmA, anyptr_gpB); 1969 e->vbroadcastsd(ymmA, anyptr_gpB); 1970 e->vbroadcastss(xmmA, anyptr_gpB); 1971 e->vbroadcastss(ymmA, anyptr_gpB); 1972 e->vcmppd(xmmA, xmmB, xmmC, 0); 1973 e->vcmppd(xmmA, xmmB, anyptr_gpC, 0); 1974 e->vcmppd(ymmA, ymmB, ymmC, 0); 1975 e->vcmppd(ymmA, ymmB, anyptr_gpC, 0); 1976 e->vcmpps(xmmA, xmmB, xmmC, 0); 1977 e->vcmpps(xmmA, xmmB, anyptr_gpC, 0); 1978 e->vcmpps(ymmA, ymmB, ymmC, 0); 1979 e->vcmpps(ymmA, ymmB, anyptr_gpC, 0); 1980 e->vcmpsd(xmmA, xmmB, xmmC, 0); 1981 e->vcmpsd(xmmA, xmmB, anyptr_gpC, 0); 1982 e->vcmpss(xmmA, xmmB, xmmC, 0); 1983 e->vcmpss(xmmA, xmmB, anyptr_gpC, 0); 1984 e->vcomisd(xmmA, xmmB); 1985 e->vcomisd(xmmA, anyptr_gpB); 1986 e->vcomiss(xmmA, xmmB); 1987 e->vcomiss(xmmA, anyptr_gpB); 1988 e->vcvtdq2pd(xmmA, xmmB); 1989 e->vcvtdq2pd(xmmA, anyptr_gpB); 1990 e->vcvtdq2pd(ymmA, xmmB); 1991 e->vcvtdq2pd(ymmA, anyptr_gpB); 1992 e->vcvtdq2ps(xmmA, xmmB); 1993 e->vcvtdq2ps(xmmA, anyptr_gpB); 1994 e->vcvtdq2ps(ymmA, ymmB); 1995 e->vcvtdq2ps(ymmA, anyptr_gpB); 1996 e->vcvtpd2dq(xmmA, xmmB); 1997 e->vcvtpd2dq(xmmA, ymmB); 1998 e->vcvtpd2dq(xmmA, anyptr_gpB); 1999 e->vcvtpd2ps(xmmA, xmmB); 2000 e->vcvtpd2ps(xmmA, ymmB); 2001 e->vcvtpd2ps(xmmA, anyptr_gpB); 2002 e->vcvtps2dq(xmmA, xmmB); 2003 e->vcvtps2dq(xmmA, anyptr_gpB); 2004 e->vcvtps2dq(ymmA, ymmB); 2005 e->vcvtps2dq(ymmA, anyptr_gpB); 2006 e->vcvtps2pd(xmmA, xmmB); 2007 e->vcvtps2pd(xmmA, anyptr_gpB); 2008 e->vcvtps2pd(ymmA, xmmB); 2009 e->vcvtps2pd(ymmA, anyptr_gpB); 2010 e->vcvtsd2si(gzA, xmmB); 2011 e->vcvtsd2si(gzA, anyptr_gpB); 2012 e->vcvtsd2ss(xmmA, xmmB, xmmC); 2013 e->vcvtsd2ss(xmmA, xmmB, anyptr_gpC); 2014 e->vcvtsi2sd(xmmA, xmmB, gzC); 2015 e->vcvtsi2sd(xmmA, xmmB, anyptr_gpC); 2016 e->vcvtsi2ss(xmmA, xmmB, gzC); 2017 e->vcvtsi2ss(xmmA, xmmB, anyptr_gpC); 2018 e->vcvtss2sd(xmmA, xmmB, xmmC); 2019 e->vcvtss2sd(xmmA, xmmB, anyptr_gpC); 2020 e->vcvtss2si(gzA, xmmB); 2021 e->vcvtss2si(gzA, anyptr_gpB); 2022 e->vcvttpd2dq(xmmA, xmmB); 2023 e->vcvttpd2dq(xmmA, ymmB); 2024 e->vcvttpd2dq(xmmA, anyptr_gpB); 2025 e->vcvttps2dq(xmmA, xmmB); 2026 e->vcvttps2dq(xmmA, anyptr_gpB); 2027 e->vcvttps2dq(ymmA, ymmB); 2028 e->vcvttps2dq(ymmA, anyptr_gpB); 2029 e->vcvttsd2si(gzA, xmmB); 2030 e->vcvttsd2si(gzA, anyptr_gpB); 2031 e->vcvttss2si(gzA, xmmB); 2032 e->vcvttss2si(gzA, anyptr_gpB); 2033 e->vdivpd(xmmA, xmmB, xmmC); 2034 e->vdivpd(xmmA, xmmB, anyptr_gpC); 2035 e->vdivpd(ymmA, ymmB, ymmC); 2036 e->vdivpd(ymmA, ymmB, anyptr_gpC); 2037 e->vdivps(xmmA, xmmB, xmmC); 2038 e->vdivps(xmmA, xmmB, anyptr_gpC); 2039 e->vdivps(ymmA, ymmB, ymmC); 2040 e->vdivps(ymmA, ymmB, anyptr_gpC); 2041 e->vdivsd(xmmA, xmmB, xmmC); 2042 e->vdivsd(xmmA, xmmB, anyptr_gpC); 2043 e->vdivss(xmmA, xmmB, xmmC); 2044 e->vdivss(xmmA, xmmB, anyptr_gpC); 2045 e->vdppd(xmmA, xmmB, xmmC, 0); 2046 e->vdppd(xmmA, xmmB, anyptr_gpC, 0); 2047 e->vdpps(xmmA, xmmB, xmmC, 0); 2048 e->vdpps(xmmA, xmmB, anyptr_gpC, 0); 2049 e->vdpps(ymmA, ymmB, ymmC, 0); 2050 e->vdpps(ymmA, ymmB, anyptr_gpC, 0); 2051 e->vextractf128(xmmA, ymmB, 0); 2052 e->vextractf128(anyptr_gpA, ymmB, 0); 2053 e->vextractps(gzA, xmmB, 0); 2054 e->vextractps(anyptr_gpA, xmmB, 0); 2055 e->vhaddpd(xmmA, xmmB, xmmC); 2056 e->vhaddpd(xmmA, xmmB, anyptr_gpC); 2057 e->vhaddpd(ymmA, ymmB, ymmC); 2058 e->vhaddpd(ymmA, ymmB, anyptr_gpC); 2059 e->vhaddps(xmmA, xmmB, xmmC); 2060 e->vhaddps(xmmA, xmmB, anyptr_gpC); 2061 e->vhaddps(ymmA, ymmB, ymmC); 2062 e->vhaddps(ymmA, ymmB, anyptr_gpC); 2063 e->vhsubpd(xmmA, xmmB, xmmC); 2064 e->vhsubpd(xmmA, xmmB, anyptr_gpC); 2065 e->vhsubpd(ymmA, ymmB, ymmC); 2066 e->vhsubpd(ymmA, ymmB, anyptr_gpC); 2067 e->vhsubps(xmmA, xmmB, xmmC); 2068 e->vhsubps(xmmA, xmmB, anyptr_gpC); 2069 e->vhsubps(ymmA, ymmB, ymmC); 2070 e->vhsubps(ymmA, ymmB, anyptr_gpC); 2071 e->vinsertf128(ymmA, ymmB, xmmC, 0); 2072 e->vinsertf128(ymmA, ymmB, anyptr_gpC, 0); 2073 e->vinsertps(xmmA, xmmB, xmmC, 0); 2074 e->vinsertps(xmmA, xmmB, anyptr_gpC, 0); 2075 e->vlddqu(xmmA, anyptr_gpB); 2076 e->vlddqu(ymmA, anyptr_gpB); 2077 e->vldmxcsr(anyptr_gpA); 2078 e->vmaskmovdqu(xmmA, xmmB); // Implicit xmmA, xmmB, <ds:[EDI|RDI]> 2079 e->vmaskmovdqu(xmmA, xmmB, ptr(e->zdi())); // Explicit xmmA, xmmB, <ds:[EDI|RDI]> 2080 e->vmaskmovps(xmmA, xmmB, anyptr_gpC); 2081 e->vmaskmovps(ymmA, ymmB, anyptr_gpC); 2082 e->vmaskmovps(anyptr_gpA, xmmB, xmmC); 2083 e->vmaskmovps(anyptr_gpA, ymmB, ymmC); 2084 e->vmaskmovpd(xmmA, xmmB, anyptr_gpC); 2085 e->vmaskmovpd(ymmA, ymmB, anyptr_gpC); 2086 e->vmaskmovpd(anyptr_gpA, xmmB, xmmC); 2087 e->vmaskmovpd(anyptr_gpA, ymmB, ymmC); 2088 e->vmaxpd(xmmA, xmmB, xmmC); 2089 e->vmaxpd(xmmA, xmmB, anyptr_gpC); 2090 e->vmaxpd(ymmA, ymmB, ymmC); 2091 e->vmaxpd(ymmA, ymmB, anyptr_gpC); 2092 e->vmaxps(xmmA, xmmB, xmmC); 2093 e->vmaxps(xmmA, xmmB, anyptr_gpC); 2094 e->vmaxps(ymmA, ymmB, ymmC); 2095 e->vmaxps(ymmA, ymmB, anyptr_gpC); 2096 e->vmaxsd(xmmA, xmmB, xmmC); 2097 e->vmaxsd(xmmA, xmmB, anyptr_gpC); 2098 e->vmaxss(xmmA, xmmB, xmmC); 2099 e->vmaxss(xmmA, xmmB, anyptr_gpC); 2100 e->vminpd(xmmA, xmmB, xmmC); 2101 e->vminpd(xmmA, xmmB, anyptr_gpC); 2102 e->vminpd(ymmA, ymmB, ymmC); 2103 e->vminpd(ymmA, ymmB, anyptr_gpC); 2104 e->vminps(xmmA, xmmB, xmmC); 2105 e->vminps(xmmA, xmmB, anyptr_gpC); 2106 e->vminps(ymmA, ymmB, ymmC); 2107 e->vminps(ymmA, ymmB, anyptr_gpC); 2108 e->vminsd(xmmA, xmmB, xmmC); 2109 e->vminsd(xmmA, xmmB, anyptr_gpC); 2110 e->vminss(xmmA, xmmB, xmmC); 2111 e->vminss(xmmA, xmmB, anyptr_gpC); 2112 e->vmovapd(xmmA, xmmB); 2113 e->vmovapd(xmmA, anyptr_gpB); 2114 e->vmovapd(anyptr_gpA, xmmB); 2115 e->vmovapd(ymmA, ymmB); 2116 e->vmovapd(ymmA, anyptr_gpB); 2117 e->vmovapd(anyptr_gpA, ymmB); 2118 e->vmovaps(xmmA, xmmB); 2119 e->vmovaps(xmmA, anyptr_gpB); 2120 e->vmovaps(anyptr_gpA, xmmB); 2121 e->vmovaps(ymmA, ymmB); 2122 e->vmovaps(ymmA, anyptr_gpB); 2123 e->vmovaps(anyptr_gpA, ymmB); 2124 e->vmovd(xmmA, gzB); 2125 e->vmovd(xmmA, anyptr_gpB); 2126 e->vmovd(gzA, xmmB); 2127 e->vmovd(anyptr_gpA, xmmB); 2128 e->vmovddup(xmmA, xmmB); 2129 e->vmovddup(xmmA, anyptr_gpB); 2130 e->vmovddup(ymmA, ymmB); 2131 e->vmovddup(ymmA, anyptr_gpB); 2132 e->vmovdqa(xmmA, xmmB); 2133 e->vmovdqa(xmmA, anyptr_gpB); 2134 e->vmovdqa(anyptr_gpA, xmmB); 2135 e->vmovdqa(ymmA, ymmB); 2136 e->vmovdqa(ymmA, anyptr_gpB); 2137 e->vmovdqa(anyptr_gpA, ymmB); 2138 e->vmovdqu(xmmA, xmmB); 2139 e->vmovdqu(xmmA, anyptr_gpB); 2140 e->vmovdqu(anyptr_gpA, xmmB); 2141 e->vmovdqu(ymmA, ymmB); 2142 e->vmovdqu(ymmA, anyptr_gpB); 2143 e->vmovdqu(anyptr_gpA, ymmB); 2144 e->vmovhlps(xmmA, xmmB, xmmC); 2145 e->vmovhpd(xmmA, xmmB, anyptr_gpC); 2146 e->vmovhpd(anyptr_gpA, xmmB); 2147 e->vmovhps(xmmA, xmmB, anyptr_gpC); 2148 e->vmovhps(anyptr_gpA, xmmB); 2149 e->vmovlhps(xmmA, xmmB, xmmC); 2150 e->vmovlpd(xmmA, xmmB, anyptr_gpC); 2151 e->vmovlpd(anyptr_gpA, xmmB); 2152 e->vmovlps(xmmA, xmmB, anyptr_gpC); 2153 e->vmovlps(anyptr_gpA, xmmB); 2154 e->vmovmskpd(gzA, xmmB); 2155 e->vmovmskpd(gzA, ymmB); 2156 e->vmovmskps(gzA, xmmB); 2157 e->vmovmskps(gzA, ymmB); 2158 e->vmovntdq(anyptr_gpA, xmmB); 2159 e->vmovntdq(anyptr_gpA, ymmB); 2160 e->vmovntdqa(xmmA, anyptr_gpB); 2161 e->vmovntpd(anyptr_gpA, xmmB); 2162 e->vmovntpd(anyptr_gpA, ymmB); 2163 e->vmovntps(anyptr_gpA, xmmB); 2164 e->vmovntps(anyptr_gpA, ymmB); 2165 e->vmovsd(xmmA, xmmB, xmmC); 2166 e->vmovsd(xmmA, anyptr_gpB); 2167 e->vmovsd(anyptr_gpA, xmmB); 2168 e->vmovshdup(xmmA, xmmB); 2169 e->vmovshdup(xmmA, anyptr_gpB); 2170 e->vmovshdup(ymmA, ymmB); 2171 e->vmovshdup(ymmA, anyptr_gpB); 2172 e->vmovsldup(xmmA, xmmB); 2173 e->vmovsldup(xmmA, anyptr_gpB); 2174 e->vmovsldup(ymmA, ymmB); 2175 e->vmovsldup(ymmA, anyptr_gpB); 2176 e->vmovss(xmmA, xmmB, xmmC); 2177 e->vmovss(xmmA, anyptr_gpB); 2178 e->vmovss(anyptr_gpA, xmmB); 2179 e->vmovupd(xmmA, xmmB); 2180 e->vmovupd(xmmA, anyptr_gpB); 2181 e->vmovupd(anyptr_gpA, xmmB); 2182 e->vmovupd(ymmA, ymmB); 2183 e->vmovupd(ymmA, anyptr_gpB); 2184 e->vmovupd(anyptr_gpA, ymmB); 2185 e->vmovups(xmmA, xmmB); 2186 e->vmovups(xmmA, anyptr_gpB); 2187 e->vmovups(anyptr_gpA, xmmB); 2188 e->vmovups(ymmA, ymmB); 2189 e->vmovups(ymmA, anyptr_gpB); 2190 e->vmovups(anyptr_gpA, ymmB); 2191 e->vmpsadbw(xmmA, xmmB, xmmC, 0); 2192 e->vmpsadbw(xmmA, xmmB, anyptr_gpC, 0); 2193 e->vmulpd(xmmA, xmmB, xmmC); 2194 e->vmulpd(xmmA, xmmB, anyptr_gpC); 2195 e->vmulpd(ymmA, ymmB, ymmC); 2196 e->vmulpd(ymmA, ymmB, anyptr_gpC); 2197 e->vmulps(xmmA, xmmB, xmmC); 2198 e->vmulps(xmmA, xmmB, anyptr_gpC); 2199 e->vmulps(ymmA, ymmB, ymmC); 2200 e->vmulps(ymmA, ymmB, anyptr_gpC); 2201 e->vmulsd(xmmA, xmmB, xmmC); 2202 e->vmulsd(xmmA, xmmB, anyptr_gpC); 2203 e->vmulss(xmmA, xmmB, xmmC); 2204 e->vmulss(xmmA, xmmB, anyptr_gpC); 2205 e->vorpd(xmmA, xmmB, xmmC); 2206 e->vorpd(xmmA, xmmB, anyptr_gpC); 2207 e->vorpd(ymmA, ymmB, ymmC); 2208 e->vorpd(ymmA, ymmB, anyptr_gpC); 2209 e->vorps(xmmA, xmmB, xmmC); 2210 e->vorps(xmmA, xmmB, anyptr_gpC); 2211 e->vorps(ymmA, ymmB, ymmC); 2212 e->vorps(ymmA, ymmB, anyptr_gpC); 2213 e->vpabsb(xmmA, xmmB); 2214 e->vpabsb(xmmA, anyptr_gpB); 2215 e->vpabsd(xmmA, xmmB); 2216 e->vpabsd(xmmA, anyptr_gpB); 2217 e->vpabsw(xmmA, xmmB); 2218 e->vpabsw(xmmA, anyptr_gpB); 2219 e->vpackssdw(xmmA, xmmB, xmmC); 2220 e->vpackssdw(xmmA, xmmB, anyptr_gpC); 2221 e->vpacksswb(xmmA, xmmB, xmmC); 2222 e->vpacksswb(xmmA, xmmB, anyptr_gpC); 2223 e->vpackusdw(xmmA, xmmB, xmmC); 2224 e->vpackusdw(xmmA, xmmB, anyptr_gpC); 2225 e->vpackuswb(xmmA, xmmB, xmmC); 2226 e->vpackuswb(xmmA, xmmB, anyptr_gpC); 2227 e->vpaddb(xmmA, xmmB, xmmC); 2228 e->vpaddb(xmmA, xmmB, anyptr_gpC); 2229 e->vpaddd(xmmA, xmmB, xmmC); 2230 e->vpaddd(xmmA, xmmB, anyptr_gpC); 2231 e->vpaddq(xmmA, xmmB, xmmC); 2232 e->vpaddq(xmmA, xmmB, anyptr_gpC); 2233 e->vpaddw(xmmA, xmmB, xmmC); 2234 e->vpaddw(xmmA, xmmB, anyptr_gpC); 2235 e->vpaddsb(xmmA, xmmB, xmmC); 2236 e->vpaddsb(xmmA, xmmB, anyptr_gpC); 2237 e->vpaddsw(xmmA, xmmB, xmmC); 2238 e->vpaddsw(xmmA, xmmB, anyptr_gpC); 2239 e->vpaddusb(xmmA, xmmB, xmmC); 2240 e->vpaddusb(xmmA, xmmB, anyptr_gpC); 2241 e->vpaddusw(xmmA, xmmB, xmmC); 2242 e->vpaddusw(xmmA, xmmB, anyptr_gpC); 2243 e->vpalignr(xmmA, xmmB, xmmC, 0); 2244 e->vpalignr(xmmA, xmmB, anyptr_gpC, 0); 2245 e->vpand(xmmA, xmmB, xmmC); 2246 e->vpand(xmmA, xmmB, anyptr_gpC); 2247 e->vpandn(xmmA, xmmB, xmmC); 2248 e->vpandn(xmmA, xmmB, anyptr_gpC); 2249 e->vpavgb(xmmA, xmmB, xmmC); 2250 e->vpavgb(xmmA, xmmB, anyptr_gpC); 2251 e->vpavgw(xmmA, xmmB, xmmC); 2252 e->vpavgw(xmmA, xmmB, anyptr_gpC); 2253 e->vpblendvb(xmmA, xmmB, xmmC, xmmD); 2254 e->vpblendvb(xmmA, xmmB, anyptr_gpC, xmmD); 2255 e->vpblendw(xmmA, xmmB, xmmC, 0); 2256 e->vpblendw(xmmA, xmmB, anyptr_gpC, 0); 2257 e->vpcmpeqb(xmmA, xmmB, xmmC); 2258 e->vpcmpeqb(xmmA, xmmB, anyptr_gpC); 2259 e->vpcmpeqd(xmmA, xmmB, xmmC); 2260 e->vpcmpeqd(xmmA, xmmB, anyptr_gpC); 2261 e->vpcmpeqq(xmmA, xmmB, xmmC); 2262 e->vpcmpeqq(xmmA, xmmB, anyptr_gpC); 2263 e->vpcmpeqw(xmmA, xmmB, xmmC); 2264 e->vpcmpeqw(xmmA, xmmB, anyptr_gpC); 2265 e->vpcmpgtb(xmmA, xmmB, xmmC); 2266 e->vpcmpgtb(xmmA, xmmB, anyptr_gpC); 2267 e->vpcmpgtd(xmmA, xmmB, xmmC); 2268 e->vpcmpgtd(xmmA, xmmB, anyptr_gpC); 2269 e->vpcmpgtq(xmmA, xmmB, xmmC); 2270 e->vpcmpgtq(xmmA, xmmB, anyptr_gpC); 2271 e->vpcmpgtw(xmmA, xmmB, xmmC); 2272 e->vpcmpgtw(xmmA, xmmB, anyptr_gpC); 2273 e->vpcmpestri(xmmA, xmmB, 0); 2274 e->vpcmpestri(xmmA, anyptr_gpB, 0); 2275 e->vpcmpestrm(xmmA, xmmB, 0); 2276 e->vpcmpestrm(xmmA, anyptr_gpB, 0); 2277 e->vpcmpistri(xmmA, xmmB, 0); 2278 e->vpcmpistri(xmmA, anyptr_gpB, 0); 2279 e->vpcmpistrm(xmmA, xmmB, 0); 2280 e->vpcmpistrm(xmmA, anyptr_gpB, 0); 2281 e->vpermilpd(xmmA, xmmB, xmmC); 2282 e->vpermilpd(xmmA, xmmB, anyptr_gpC); 2283 e->vpermilpd(ymmA, ymmB, ymmC); 2284 e->vpermilpd(ymmA, ymmB, anyptr_gpC); 2285 e->vpermilpd(xmmA, xmmB, 0); 2286 e->vpermilpd(xmmA, anyptr_gpB, 0); 2287 e->vpermilpd(ymmA, ymmB, 0); 2288 e->vpermilpd(ymmA, anyptr_gpB, 0); 2289 e->vpermilps(xmmA, xmmB, xmmC); 2290 e->vpermilps(xmmA, xmmB, anyptr_gpC); 2291 e->vpermilps(ymmA, ymmB, ymmC); 2292 e->vpermilps(ymmA, ymmB, anyptr_gpC); 2293 e->vpermilps(xmmA, xmmB, 0); 2294 e->vpermilps(xmmA, anyptr_gpB, 0); 2295 e->vpermilps(ymmA, ymmB, 0); 2296 e->vpermilps(ymmA, anyptr_gpB, 0); 2297 e->vperm2f128(ymmA, ymmB, ymmC, 0); 2298 e->vperm2f128(ymmA, ymmB, anyptr_gpC, 0); 2299 e->vpextrb(gzA, xmmB, 0); 2300 e->vpextrb(anyptr_gpA, xmmB, 0); 2301 e->vpextrd(gzA, xmmB, 0); 2302 e->vpextrd(anyptr_gpA, xmmB, 0); 2303 if (isX64) e->vpextrq(gzA, xmmB, 0); 2304 if (isX64) e->vpextrq(anyptr_gpA, xmmB, 0); 2305 e->vpextrw(gzA, xmmB, 0); 2306 e->vpextrw(anyptr_gpA, xmmB, 0); 2307 e->vphaddd(xmmA, xmmB, xmmC); 2308 e->vphaddd(xmmA, xmmB, anyptr_gpC); 2309 e->vphaddsw(xmmA, xmmB, xmmC); 2310 e->vphaddsw(xmmA, xmmB, anyptr_gpC); 2311 e->vphaddw(xmmA, xmmB, xmmC); 2312 e->vphaddw(xmmA, xmmB, anyptr_gpC); 2313 e->vphminposuw(xmmA, xmmB); 2314 e->vphminposuw(xmmA, anyptr_gpB); 2315 e->vphsubd(xmmA, xmmB, xmmC); 2316 e->vphsubd(xmmA, xmmB, anyptr_gpC); 2317 e->vphsubsw(xmmA, xmmB, xmmC); 2318 e->vphsubsw(xmmA, xmmB, anyptr_gpC); 2319 e->vphsubw(xmmA, xmmB, xmmC); 2320 e->vphsubw(xmmA, xmmB, anyptr_gpC); 2321 e->vpinsrb(xmmA, xmmB, gzC, 0); 2322 e->vpinsrb(xmmA, xmmB, anyptr_gpC, 0); 2323 e->vpinsrd(xmmA, xmmB, gzC, 0); 2324 e->vpinsrd(xmmA, xmmB, anyptr_gpC, 0); 2325 e->vpinsrw(xmmA, xmmB, gzC, 0); 2326 e->vpinsrw(xmmA, xmmB, anyptr_gpC, 0); 2327 e->vpmaddubsw(xmmA, xmmB, xmmC); 2328 e->vpmaddubsw(xmmA, xmmB, anyptr_gpC); 2329 e->vpmaddwd(xmmA, xmmB, xmmC); 2330 e->vpmaddwd(xmmA, xmmB, anyptr_gpC); 2331 e->vpmaxsb(xmmA, xmmB, xmmC); 2332 e->vpmaxsb(xmmA, xmmB, anyptr_gpC); 2333 e->vpmaxsd(xmmA, xmmB, xmmC); 2334 e->vpmaxsd(xmmA, xmmB, anyptr_gpC); 2335 e->vpmaxsw(xmmA, xmmB, xmmC); 2336 e->vpmaxsw(xmmA, xmmB, anyptr_gpC); 2337 e->vpmaxub(xmmA, xmmB, xmmC); 2338 e->vpmaxub(xmmA, xmmB, anyptr_gpC); 2339 e->vpmaxud(xmmA, xmmB, xmmC); 2340 e->vpmaxud(xmmA, xmmB, anyptr_gpC); 2341 e->vpmaxuw(xmmA, xmmB, xmmC); 2342 e->vpmaxuw(xmmA, xmmB, anyptr_gpC); 2343 e->vpminsb(xmmA, xmmB, xmmC); 2344 e->vpminsb(xmmA, xmmB, anyptr_gpC); 2345 e->vpminsd(xmmA, xmmB, xmmC); 2346 e->vpminsd(xmmA, xmmB, anyptr_gpC); 2347 e->vpminsw(xmmA, xmmB, xmmC); 2348 e->vpminsw(xmmA, xmmB, anyptr_gpC); 2349 e->vpminub(xmmA, xmmB, xmmC); 2350 e->vpminub(xmmA, xmmB, anyptr_gpC); 2351 e->vpminud(xmmA, xmmB, xmmC); 2352 e->vpminud(xmmA, xmmB, anyptr_gpC); 2353 e->vpminuw(xmmA, xmmB, xmmC); 2354 e->vpminuw(xmmA, xmmB, anyptr_gpC); 2355 e->vpmovmskb(gzA, xmmB); 2356 e->vpmovsxbd(xmmA, xmmB); 2357 e->vpmovsxbd(xmmA, anyptr_gpB); 2358 e->vpmovsxbq(xmmA, xmmB); 2359 e->vpmovsxbq(xmmA, anyptr_gpB); 2360 e->vpmovsxbw(xmmA, xmmB); 2361 e->vpmovsxbw(xmmA, anyptr_gpB); 2362 e->vpmovsxdq(xmmA, xmmB); 2363 e->vpmovsxdq(xmmA, anyptr_gpB); 2364 e->vpmovsxwd(xmmA, xmmB); 2365 e->vpmovsxwd(xmmA, anyptr_gpB); 2366 e->vpmovsxwq(xmmA, xmmB); 2367 e->vpmovsxwq(xmmA, anyptr_gpB); 2368 e->vpmovzxbd(xmmA, xmmB); 2369 e->vpmovzxbd(xmmA, anyptr_gpB); 2370 e->vpmovzxbq(xmmA, xmmB); 2371 e->vpmovzxbq(xmmA, anyptr_gpB); 2372 e->vpmovzxbw(xmmA, xmmB); 2373 e->vpmovzxbw(xmmA, anyptr_gpB); 2374 e->vpmovzxdq(xmmA, xmmB); 2375 e->vpmovzxdq(xmmA, anyptr_gpB); 2376 e->vpmovzxwd(xmmA, xmmB); 2377 e->vpmovzxwd(xmmA, anyptr_gpB); 2378 e->vpmovzxwq(xmmA, xmmB); 2379 e->vpmovzxwq(xmmA, anyptr_gpB); 2380 e->vpmuldq(xmmA, xmmB, xmmC); 2381 e->vpmuldq(xmmA, xmmB, anyptr_gpC); 2382 e->vpmulhrsw(xmmA, xmmB, xmmC); 2383 e->vpmulhrsw(xmmA, xmmB, anyptr_gpC); 2384 e->vpmulhuw(xmmA, xmmB, xmmC); 2385 e->vpmulhuw(xmmA, xmmB, anyptr_gpC); 2386 e->vpmulhw(xmmA, xmmB, xmmC); 2387 e->vpmulhw(xmmA, xmmB, anyptr_gpC); 2388 e->vpmulld(xmmA, xmmB, xmmC); 2389 e->vpmulld(xmmA, xmmB, anyptr_gpC); 2390 e->vpmullw(xmmA, xmmB, xmmC); 2391 e->vpmullw(xmmA, xmmB, anyptr_gpC); 2392 e->vpmuludq(xmmA, xmmB, xmmC); 2393 e->vpmuludq(xmmA, xmmB, anyptr_gpC); 2394 e->vpor(xmmA, xmmB, xmmC); 2395 e->vpor(xmmA, xmmB, anyptr_gpC); 2396 e->vpsadbw(xmmA, xmmB, xmmC); 2397 e->vpsadbw(xmmA, xmmB, anyptr_gpC); 2398 e->vpshufb(xmmA, xmmB, xmmC); 2399 e->vpshufb(xmmA, xmmB, anyptr_gpC); 2400 e->vpshufd(xmmA, xmmB, 0); 2401 e->vpshufd(xmmA, anyptr_gpB, 0); 2402 e->vpshufhw(xmmA, xmmB, 0); 2403 e->vpshufhw(xmmA, anyptr_gpB, 0); 2404 e->vpshuflw(xmmA, xmmB, 0); 2405 e->vpshuflw(xmmA, anyptr_gpB, 0); 2406 e->vpsignb(xmmA, xmmB, xmmC); 2407 e->vpsignb(xmmA, xmmB, anyptr_gpC); 2408 e->vpsignd(xmmA, xmmB, xmmC); 2409 e->vpsignd(xmmA, xmmB, anyptr_gpC); 2410 e->vpsignw(xmmA, xmmB, xmmC); 2411 e->vpsignw(xmmA, xmmB, anyptr_gpC); 2412 e->vpslld(xmmA, xmmB, xmmC); 2413 e->vpslld(xmmA, xmmB, anyptr_gpC); 2414 e->vpslld(xmmA, xmmB, 0); 2415 e->vpslldq(xmmA, xmmB, 0); 2416 e->vpsllq(xmmA, xmmB, xmmC); 2417 e->vpsllq(xmmA, xmmB, anyptr_gpC); 2418 e->vpsllq(xmmA, xmmB, 0); 2419 e->vpsllw(xmmA, xmmB, xmmC); 2420 e->vpsllw(xmmA, xmmB, anyptr_gpC); 2421 e->vpsllw(xmmA, xmmB, 0); 2422 e->vpsrad(xmmA, xmmB, xmmC); 2423 e->vpsrad(xmmA, xmmB, anyptr_gpC); 2424 e->vpsrad(xmmA, xmmB, 0); 2425 e->vpsraw(xmmA, xmmB, xmmC); 2426 e->vpsraw(xmmA, xmmB, anyptr_gpC); 2427 e->vpsraw(xmmA, xmmB, 0); 2428 e->vpsrld(xmmA, xmmB, xmmC); 2429 e->vpsrld(xmmA, xmmB, anyptr_gpC); 2430 e->vpsrld(xmmA, xmmB, 0); 2431 e->vpsrldq(xmmA, xmmB, 0); 2432 e->vpsrlq(xmmA, xmmB, xmmC); 2433 e->vpsrlq(xmmA, xmmB, anyptr_gpC); 2434 e->vpsrlq(xmmA, xmmB, 0); 2435 e->vpsrlw(xmmA, xmmB, xmmC); 2436 e->vpsrlw(xmmA, xmmB, anyptr_gpC); 2437 e->vpsrlw(xmmA, xmmB, 0); 2438 e->vpsubb(xmmA, xmmB, xmmC); 2439 e->vpsubb(xmmA, xmmB, anyptr_gpC); 2440 e->vpsubd(xmmA, xmmB, xmmC); 2441 e->vpsubd(xmmA, xmmB, anyptr_gpC); 2442 e->vpsubq(xmmA, xmmB, xmmC); 2443 e->vpsubq(xmmA, xmmB, anyptr_gpC); 2444 e->vpsubw(xmmA, xmmB, xmmC); 2445 e->vpsubw(xmmA, xmmB, anyptr_gpC); 2446 e->vpsubsb(xmmA, xmmB, xmmC); 2447 e->vpsubsb(xmmA, xmmB, anyptr_gpC); 2448 e->vpsubsw(xmmA, xmmB, xmmC); 2449 e->vpsubsw(xmmA, xmmB, anyptr_gpC); 2450 e->vpsubusb(xmmA, xmmB, xmmC); 2451 e->vpsubusb(xmmA, xmmB, anyptr_gpC); 2452 e->vpsubusw(xmmA, xmmB, xmmC); 2453 e->vpsubusw(xmmA, xmmB, anyptr_gpC); 2454 e->vptest(xmmA, xmmB); 2455 e->vptest(xmmA, anyptr_gpB); 2456 e->vptest(ymmA, ymmB); 2457 e->vptest(ymmA, anyptr_gpB); 2458 e->vpunpckhbw(xmmA, xmmB, xmmC); 2459 e->vpunpckhbw(xmmA, xmmB, anyptr_gpC); 2460 e->vpunpckhdq(xmmA, xmmB, xmmC); 2461 e->vpunpckhdq(xmmA, xmmB, anyptr_gpC); 2462 e->vpunpckhqdq(xmmA, xmmB, xmmC); 2463 e->vpunpckhqdq(xmmA, xmmB, anyptr_gpC); 2464 e->vpunpckhwd(xmmA, xmmB, xmmC); 2465 e->vpunpckhwd(xmmA, xmmB, anyptr_gpC); 2466 e->vpunpcklbw(xmmA, xmmB, xmmC); 2467 e->vpunpcklbw(xmmA, xmmB, anyptr_gpC); 2468 e->vpunpckldq(xmmA, xmmB, xmmC); 2469 e->vpunpckldq(xmmA, xmmB, anyptr_gpC); 2470 e->vpunpcklqdq(xmmA, xmmB, xmmC); 2471 e->vpunpcklqdq(xmmA, xmmB, anyptr_gpC); 2472 e->vpunpcklwd(xmmA, xmmB, xmmC); 2473 e->vpunpcklwd(xmmA, xmmB, anyptr_gpC); 2474 e->vpxor(xmmA, xmmB, xmmC); 2475 e->vpxor(xmmA, xmmB, anyptr_gpC); 2476 e->vrcpps(xmmA, xmmB); 2477 e->vrcpps(xmmA, anyptr_gpB); 2478 e->vrcpps(ymmA, ymmB); 2479 e->vrcpps(ymmA, anyptr_gpB); 2480 e->vrcpss(xmmA, xmmB, xmmC); 2481 e->vrcpss(xmmA, xmmB, anyptr_gpC); 2482 e->vrsqrtps(xmmA, xmmB); 2483 e->vrsqrtps(xmmA, anyptr_gpB); 2484 e->vrsqrtps(ymmA, ymmB); 2485 e->vrsqrtps(ymmA, anyptr_gpB); 2486 e->vrsqrtss(xmmA, xmmB, xmmC); 2487 e->vrsqrtss(xmmA, xmmB, anyptr_gpC); 2488 e->vroundpd(xmmA, xmmB, 0); 2489 e->vroundpd(xmmA, anyptr_gpB, 0); 2490 e->vroundpd(ymmA, ymmB, 0); 2491 e->vroundpd(ymmA, anyptr_gpB, 0); 2492 e->vroundps(xmmA, xmmB, 0); 2493 e->vroundps(xmmA, anyptr_gpB, 0); 2494 e->vroundps(ymmA, ymmB, 0); 2495 e->vroundps(ymmA, anyptr_gpB, 0); 2496 e->vroundsd(xmmA, xmmB, xmmC, 0); 2497 e->vroundsd(xmmA, xmmB, anyptr_gpC, 0); 2498 e->vroundss(xmmA, xmmB, xmmC, 0); 2499 e->vroundss(xmmA, xmmB, anyptr_gpC, 0); 2500 e->vshufpd(xmmA, xmmB, xmmC, 0); 2501 e->vshufpd(xmmA, xmmB, anyptr_gpC, 0); 2502 e->vshufpd(ymmA, ymmB, ymmC, 0); 2503 e->vshufpd(ymmA, ymmB, anyptr_gpC, 0); 2504 e->vshufps(xmmA, xmmB, xmmC, 0); 2505 e->vshufps(xmmA, xmmB, anyptr_gpC, 0); 2506 e->vshufps(ymmA, ymmB, ymmC, 0); 2507 e->vshufps(ymmA, ymmB, anyptr_gpC, 0); 2508 e->vsqrtpd(xmmA, xmmB); 2509 e->vsqrtpd(xmmA, anyptr_gpB); 2510 e->vsqrtpd(ymmA, ymmB); 2511 e->vsqrtpd(ymmA, anyptr_gpB); 2512 e->vsqrtps(xmmA, xmmB); 2513 e->vsqrtps(xmmA, anyptr_gpB); 2514 e->vsqrtps(ymmA, ymmB); 2515 e->vsqrtps(ymmA, anyptr_gpB); 2516 e->vsqrtsd(xmmA, xmmB, xmmC); 2517 e->vsqrtsd(xmmA, xmmB, anyptr_gpC); 2518 e->vsqrtss(xmmA, xmmB, xmmC); 2519 e->vsqrtss(xmmA, xmmB, anyptr_gpC); 2520 e->vstmxcsr(anyptr_gpA); 2521 e->vsubpd(xmmA, xmmB, xmmC); 2522 e->vsubpd(xmmA, xmmB, anyptr_gpC); 2523 e->vsubpd(ymmA, ymmB, ymmC); 2524 e->vsubpd(ymmA, ymmB, anyptr_gpC); 2525 e->vsubps(xmmA, xmmB, xmmC); 2526 e->vsubps(xmmA, xmmB, anyptr_gpC); 2527 e->vsubps(ymmA, ymmB, ymmC); 2528 e->vsubps(ymmA, ymmB, anyptr_gpC); 2529 e->vsubsd(xmmA, xmmB, xmmC); 2530 e->vsubsd(xmmA, xmmB, anyptr_gpC); 2531 e->vsubss(xmmA, xmmB, xmmC); 2532 e->vsubss(xmmA, xmmB, anyptr_gpC); 2533 e->vtestps(xmmA, xmmB); 2534 e->vtestps(xmmA, anyptr_gpB); 2535 e->vtestps(ymmA, ymmB); 2536 e->vtestps(ymmA, anyptr_gpB); 2537 e->vtestpd(xmmA, xmmB); 2538 e->vtestpd(xmmA, anyptr_gpB); 2539 e->vtestpd(ymmA, ymmB); 2540 e->vtestpd(ymmA, anyptr_gpB); 2541 e->vucomisd(xmmA, xmmB); 2542 e->vucomisd(xmmA, anyptr_gpB); 2543 e->vucomiss(xmmA, xmmB); 2544 e->vucomiss(xmmA, anyptr_gpB); 2545 e->vunpckhpd(xmmA, xmmB, xmmC); 2546 e->vunpckhpd(xmmA, xmmB, anyptr_gpC); 2547 e->vunpckhpd(ymmA, ymmB, ymmC); 2548 e->vunpckhpd(ymmA, ymmB, anyptr_gpC); 2549 e->vunpckhps(xmmA, xmmB, xmmC); 2550 e->vunpckhps(xmmA, xmmB, anyptr_gpC); 2551 e->vunpckhps(ymmA, ymmB, ymmC); 2552 e->vunpckhps(ymmA, ymmB, anyptr_gpC); 2553 e->vunpcklpd(xmmA, xmmB, xmmC); 2554 e->vunpcklpd(xmmA, xmmB, anyptr_gpC); 2555 e->vunpcklpd(ymmA, ymmB, ymmC); 2556 e->vunpcklpd(ymmA, ymmB, anyptr_gpC); 2557 e->vunpcklps(xmmA, xmmB, xmmC); 2558 e->vunpcklps(xmmA, xmmB, anyptr_gpC); 2559 e->vunpcklps(ymmA, ymmB, ymmC); 2560 e->vunpcklps(ymmA, ymmB, anyptr_gpC); 2561 e->vxorpd(xmmA, xmmB, xmmC); 2562 e->vxorpd(xmmA, xmmB, anyptr_gpC); 2563 e->vxorpd(ymmA, ymmB, ymmC); 2564 e->vxorpd(ymmA, ymmB, anyptr_gpC); 2565 e->vxorps(xmmA, xmmB, xmmC); 2566 e->vxorps(xmmA, xmmB, anyptr_gpC); 2567 e->vxorps(ymmA, ymmB, ymmC); 2568 e->vxorps(ymmA, ymmB, anyptr_gpC); 2569 e->vzeroall(); 2570 e->vex3().vzeroall(); 2571 e->vzeroupper(); 2572 e->vex3().vzeroupper(); 2573 2574 // AVX+AESNI. 2575 e->nop(); 2576 2577 e->vaesdec(xmmA, xmmB, xmmC); 2578 e->vaesdec(xmmA, xmmB, anyptr_gpC); 2579 e->vaesdeclast(xmmA, xmmB, xmmC); 2580 e->vaesdeclast(xmmA, xmmB, anyptr_gpC); 2581 e->vaesenc(xmmA, xmmB, xmmC); 2582 e->vaesenc(xmmA, xmmB, anyptr_gpC); 2583 e->vaesenclast(xmmA, xmmB, xmmC); 2584 e->vaesenclast(xmmA, xmmB, anyptr_gpC); 2585 e->vaesimc(xmmA, xmmB); 2586 e->vaesimc(xmmA, anyptr_gpB); 2587 e->vaeskeygenassist(xmmA, xmmB, 0); 2588 e->vaeskeygenassist(xmmA, anyptr_gpB, 0); 2589 2590 // AVX+PCLMULQDQ. 2591 e->nop(); 2592 2593 e->vpclmulqdq(xmmA, xmmB, xmmC, 0); 2594 e->vpclmulqdq(xmmA, xmmB, anyptr_gpC, 0); 2595 2596 // AVX2. 2597 e->nop(); 2598 2599 e->vbroadcasti128(ymmA, anyptr_gpB); 2600 e->vbroadcastsd(ymmA, xmmB); 2601 e->vbroadcastss(xmmA, xmmB); 2602 e->vbroadcastss(ymmA, xmmB); 2603 e->vextracti128(xmmA, ymmB, 0); 2604 e->vextracti128(anyptr_gpA, ymmB, 0); 2605 e->vgatherdpd(xmmA, vx_ptr, xmmC); 2606 e->vgatherdpd(ymmA, vx_ptr, ymmC); 2607 e->vgatherdps(xmmA, vx_ptr, xmmC); 2608 e->vgatherdps(ymmA, vy_ptr, ymmC); 2609 e->vgatherqpd(xmmA, vx_ptr, xmmC); 2610 e->vgatherqpd(ymmA, vy_ptr, ymmC); 2611 e->vgatherqps(xmmA, vx_ptr, xmmC); 2612 e->vgatherqps(xmmA, vy_ptr, xmmC); 2613 e->vinserti128(ymmA, ymmB, xmmC, 0); 2614 e->vinserti128(ymmA, ymmB, anyptr_gpC, 0); 2615 e->vmovntdqa(ymmA, anyptr_gpB); 2616 e->vmpsadbw(ymmA, ymmB, ymmC, 0); 2617 e->vmpsadbw(ymmA, ymmB, anyptr_gpC, 0); 2618 e->vpabsb(ymmA, ymmB); 2619 e->vpabsb(ymmA, anyptr_gpB); 2620 e->vpabsd(ymmA, ymmB); 2621 e->vpabsd(ymmA, anyptr_gpB); 2622 e->vpabsw(ymmA, ymmB); 2623 e->vpabsw(ymmA, anyptr_gpB); 2624 e->vpackssdw(ymmA, ymmB, ymmC); 2625 e->vpackssdw(ymmA, ymmB, anyptr_gpC); 2626 e->vpacksswb(ymmA, ymmB, ymmC); 2627 e->vpacksswb(ymmA, ymmB, anyptr_gpC); 2628 e->vpackusdw(ymmA, ymmB, ymmC); 2629 e->vpackusdw(ymmA, ymmB, anyptr_gpC); 2630 e->vpackuswb(ymmA, ymmB, ymmC); 2631 e->vpackuswb(ymmA, ymmB, anyptr_gpC); 2632 e->vpaddb(ymmA, ymmB, ymmC); 2633 e->vpaddb(ymmA, ymmB, anyptr_gpC); 2634 e->vpaddd(ymmA, ymmB, ymmC); 2635 e->vpaddd(ymmA, ymmB, anyptr_gpC); 2636 e->vpaddq(ymmA, ymmB, ymmC); 2637 e->vpaddq(ymmA, ymmB, anyptr_gpC); 2638 e->vpaddw(ymmA, ymmB, ymmC); 2639 e->vpaddw(ymmA, ymmB, anyptr_gpC); 2640 e->vpaddsb(ymmA, ymmB, ymmC); 2641 e->vpaddsb(ymmA, ymmB, anyptr_gpC); 2642 e->vpaddsw(ymmA, ymmB, ymmC); 2643 e->vpaddsw(ymmA, ymmB, anyptr_gpC); 2644 e->vpaddusb(ymmA, ymmB, ymmC); 2645 e->vpaddusb(ymmA, ymmB, anyptr_gpC); 2646 e->vpaddusw(ymmA, ymmB, ymmC); 2647 e->vpaddusw(ymmA, ymmB, anyptr_gpC); 2648 e->vpalignr(ymmA, ymmB, ymmC, 0); 2649 e->vpalignr(ymmA, ymmB, anyptr_gpC, 0); 2650 e->vpand(ymmA, ymmB, ymmC); 2651 e->vpand(ymmA, ymmB, anyptr_gpC); 2652 e->vpandn(ymmA, ymmB, ymmC); 2653 e->vpandn(ymmA, ymmB, anyptr_gpC); 2654 e->vpavgb(ymmA, ymmB, ymmC); 2655 e->vpavgb(ymmA, ymmB, anyptr_gpC); 2656 e->vpavgw(ymmA, ymmB, ymmC); 2657 e->vpavgw(ymmA, ymmB, anyptr_gpC); 2658 e->vpblendd(xmmA, xmmB, xmmC, 0); 2659 e->vpblendd(xmmA, xmmB, anyptr_gpC, 0); 2660 e->vpblendd(ymmA, ymmB, ymmC, 0); 2661 e->vpblendd(ymmA, ymmB, anyptr_gpC, 0); 2662 e->vpblendvb(ymmA, ymmB, ymmC, ymmD); 2663 e->vpblendvb(ymmA, ymmB, anyptr_gpC, ymmD); 2664 e->vpblendw(ymmA, ymmB, ymmC, 0); 2665 e->vpblendw(ymmA, ymmB, anyptr_gpC, 0); 2666 e->vpbroadcastb(xmmA, xmmB); 2667 e->vpbroadcastb(xmmA, anyptr_gpB); 2668 e->vpbroadcastb(ymmA, xmmB); 2669 e->vpbroadcastb(ymmA, anyptr_gpB); 2670 e->vpbroadcastd(xmmA, xmmB); 2671 e->vpbroadcastd(xmmA, anyptr_gpB); 2672 e->vpbroadcastd(ymmA, xmmB); 2673 e->vpbroadcastd(ymmA, anyptr_gpB); 2674 e->vpbroadcastq(xmmA, xmmB); 2675 e->vpbroadcastq(xmmA, anyptr_gpB); 2676 e->vpbroadcastq(ymmA, xmmB); 2677 e->vpbroadcastq(ymmA, anyptr_gpB); 2678 e->vpbroadcastw(xmmA, xmmB); 2679 e->vpbroadcastw(xmmA, anyptr_gpB); 2680 e->vpbroadcastw(ymmA, xmmB); 2681 e->vpbroadcastw(ymmA, anyptr_gpB); 2682 e->vpcmpeqb(ymmA, ymmB, ymmC); 2683 e->vpcmpeqb(ymmA, ymmB, anyptr_gpC); 2684 e->vpcmpeqd(ymmA, ymmB, ymmC); 2685 e->vpcmpeqd(ymmA, ymmB, anyptr_gpC); 2686 e->vpcmpeqq(ymmA, ymmB, ymmC); 2687 e->vpcmpeqq(ymmA, ymmB, anyptr_gpC); 2688 e->vpcmpeqw(ymmA, ymmB, ymmC); 2689 e->vpcmpeqw(ymmA, ymmB, anyptr_gpC); 2690 e->vpcmpgtb(ymmA, ymmB, ymmC); 2691 e->vpcmpgtb(ymmA, ymmB, anyptr_gpC); 2692 e->vpcmpgtd(ymmA, ymmB, ymmC); 2693 e->vpcmpgtd(ymmA, ymmB, anyptr_gpC); 2694 e->vpcmpgtq(ymmA, ymmB, ymmC); 2695 e->vpcmpgtq(ymmA, ymmB, anyptr_gpC); 2696 e->vpcmpgtw(ymmA, ymmB, ymmC); 2697 e->vpcmpgtw(ymmA, ymmB, anyptr_gpC); 2698 e->vperm2i128(ymmA, ymmB, ymmC, 0); 2699 e->vperm2i128(ymmA, ymmB, anyptr_gpC, 0); 2700 e->vpermd(ymmA, ymmB, ymmC); 2701 e->vpermd(ymmA, ymmB, anyptr_gpC); 2702 e->vpermps(ymmA, ymmB, ymmC); 2703 e->vpermps(ymmA, ymmB, anyptr_gpC); 2704 e->vpermpd(ymmA, ymmB, 0); 2705 e->vpermpd(ymmA, anyptr_gpB, 0); 2706 e->vpermq(ymmA, ymmB, 0); 2707 e->vpermq(ymmA, anyptr_gpB, 0); 2708 e->vpgatherdd(xmmA, vx_ptr, xmmC); 2709 e->vpgatherdd(ymmA, vy_ptr, ymmC); 2710 e->vpgatherdq(xmmA, vx_ptr, xmmC); 2711 e->vpgatherdq(ymmA, vx_ptr, ymmC); 2712 e->vpgatherqd(xmmA, vx_ptr, xmmC); 2713 e->vpgatherqd(xmmA, vy_ptr, xmmC); 2714 e->vpgatherqq(xmmA, vx_ptr, xmmC); 2715 e->vpgatherqq(ymmA, vy_ptr, ymmC); 2716 e->vpmovmskb(gzA, ymmB); 2717 e->vpmovsxbd(ymmA, anyptr_gpB); 2718 e->vpmovsxbd(ymmA, xmmB); 2719 e->vpmovsxbq(ymmA, anyptr_gpB); 2720 e->vpmovsxbq(ymmA, xmmB); 2721 e->vpmovsxbw(ymmA, anyptr_gpB); 2722 e->vpmovsxbw(ymmA, xmmB); 2723 e->vpmovsxdq(ymmA, anyptr_gpB); 2724 e->vpmovsxdq(ymmA, xmmB); 2725 e->vpmovsxwd(ymmA, anyptr_gpB); 2726 e->vpmovsxwd(ymmA, xmmB); 2727 e->vpmovsxwq(ymmA, anyptr_gpB); 2728 e->vpmovsxwq(ymmA, xmmB); 2729 e->vpmovzxbd(ymmA, anyptr_gpB); 2730 e->vpmovzxbd(ymmA, xmmB); 2731 e->vpmovzxbq(ymmA, anyptr_gpB); 2732 e->vpmovzxbq(ymmA, xmmB); 2733 e->vpmovzxbw(ymmA, anyptr_gpB); 2734 e->vpmovzxbw(ymmA, xmmB); 2735 e->vpmovzxdq(ymmA, anyptr_gpB); 2736 e->vpmovzxdq(ymmA, xmmB); 2737 e->vpmovzxwd(ymmA, anyptr_gpB); 2738 e->vpmovzxwd(ymmA, xmmB); 2739 e->vpmovzxwq(ymmA, anyptr_gpB); 2740 e->vpmovzxwq(ymmA, xmmB); 2741 e->vpshufd(ymmA, anyptr_gpB, 0); 2742 e->vpshufd(ymmA, ymmB, 0); 2743 e->vpshufhw(ymmA, anyptr_gpB, 0); 2744 e->vpshufhw(ymmA, ymmB, 0); 2745 e->vpshuflw(ymmA, anyptr_gpB, 0); 2746 e->vpshuflw(ymmA, ymmB, 0); 2747 e->vpslld(ymmA, ymmB, 0); 2748 e->vpslldq(ymmA, ymmB, 0); 2749 e->vpsllq(ymmA, ymmB, 0); 2750 e->vpsllw(ymmA, ymmB, 0); 2751 e->vpsrad(ymmA, ymmB, 0); 2752 e->vpsraw(ymmA, ymmB, 0); 2753 e->vpsrld(ymmA, ymmB, 0); 2754 e->vpsrldq(ymmA, ymmB, 0); 2755 e->vpsrlq(ymmA, ymmB, 0); 2756 e->vpsrlw(ymmA, ymmB, 0); 2757 e->vphaddd(ymmA, ymmB, anyptr_gpC); 2758 e->vphaddd(ymmA, ymmB, ymmC); 2759 e->vphaddsw(ymmA, ymmB, anyptr_gpC); 2760 e->vphaddsw(ymmA, ymmB, ymmC); 2761 e->vphaddw(ymmA, ymmB, anyptr_gpC); 2762 e->vphaddw(ymmA, ymmB, ymmC); 2763 e->vphsubd(ymmA, ymmB, anyptr_gpC); 2764 e->vphsubd(ymmA, ymmB, ymmC); 2765 e->vphsubsw(ymmA, ymmB, anyptr_gpC); 2766 e->vphsubsw(ymmA, ymmB, ymmC); 2767 e->vphsubw(ymmA, ymmB, anyptr_gpC); 2768 e->vphsubw(ymmA, ymmB, ymmC); 2769 e->vpmaddubsw(ymmA, ymmB, anyptr_gpC); 2770 e->vpmaddubsw(ymmA, ymmB, ymmC); 2771 e->vpmaddwd(ymmA, ymmB, anyptr_gpC); 2772 e->vpmaddwd(ymmA, ymmB, ymmC); 2773 e->vpmaskmovd(anyptr_gpA, xmmB, xmmC); 2774 e->vpmaskmovd(anyptr_gpA, ymmB, ymmC); 2775 e->vpmaskmovd(xmmA, xmmB, anyptr_gpC); 2776 e->vpmaskmovd(ymmA, ymmB, anyptr_gpC); 2777 e->vpmaskmovq(anyptr_gpA, xmmB, xmmC); 2778 e->vpmaskmovq(anyptr_gpA, ymmB, ymmC); 2779 e->vpmaskmovq(xmmA, xmmB, anyptr_gpC); 2780 e->vpmaskmovq(ymmA, ymmB, anyptr_gpC); 2781 e->vpmaxsb(ymmA, ymmB, anyptr_gpC); 2782 e->vpmaxsb(ymmA, ymmB, ymmC); 2783 e->vpmaxsd(ymmA, ymmB, anyptr_gpC); 2784 e->vpmaxsd(ymmA, ymmB, ymmC); 2785 e->vpmaxsw(ymmA, ymmB, anyptr_gpC); 2786 e->vpmaxsw(ymmA, ymmB, ymmC); 2787 e->vpmaxub(ymmA, ymmB, anyptr_gpC); 2788 e->vpmaxub(ymmA, ymmB, ymmC); 2789 e->vpmaxud(ymmA, ymmB, anyptr_gpC); 2790 e->vpmaxud(ymmA, ymmB, ymmC); 2791 e->vpmaxuw(ymmA, ymmB, anyptr_gpC); 2792 e->vpmaxuw(ymmA, ymmB, ymmC); 2793 e->vpminsb(ymmA, ymmB, anyptr_gpC); 2794 e->vpminsb(ymmA, ymmB, ymmC); 2795 e->vpminsd(ymmA, ymmB, anyptr_gpC); 2796 e->vpminsd(ymmA, ymmB, ymmC); 2797 e->vpminsw(ymmA, ymmB, anyptr_gpC); 2798 e->vpminsw(ymmA, ymmB, ymmC); 2799 e->vpminub(ymmA, ymmB, anyptr_gpC); 2800 e->vpminub(ymmA, ymmB, ymmC); 2801 e->vpminud(ymmA, ymmB, anyptr_gpC); 2802 e->vpminud(ymmA, ymmB, ymmC); 2803 e->vpminuw(ymmA, ymmB, anyptr_gpC); 2804 e->vpminuw(ymmA, ymmB, ymmC); 2805 e->vpmuldq(ymmA, ymmB, anyptr_gpC); 2806 e->vpmuldq(ymmA, ymmB, ymmC); 2807 e->vpmulhrsw(ymmA, ymmB, anyptr_gpC); 2808 e->vpmulhrsw(ymmA, ymmB, ymmC); 2809 e->vpmulhuw(ymmA, ymmB, anyptr_gpC); 2810 e->vpmulhuw(ymmA, ymmB, ymmC); 2811 e->vpmulhw(ymmA, ymmB, anyptr_gpC); 2812 e->vpmulhw(ymmA, ymmB, ymmC); 2813 e->vpmulld(ymmA, ymmB, anyptr_gpC); 2814 e->vpmulld(ymmA, ymmB, ymmC); 2815 e->vpmullw(ymmA, ymmB, anyptr_gpC); 2816 e->vpmullw(ymmA, ymmB, ymmC); 2817 e->vpmuludq(ymmA, ymmB, anyptr_gpC); 2818 e->vpmuludq(ymmA, ymmB, ymmC); 2819 e->vpor(ymmA, ymmB, anyptr_gpC); 2820 e->vpor(ymmA, ymmB, ymmC); 2821 e->vpsadbw(ymmA, ymmB, anyptr_gpC); 2822 e->vpsadbw(ymmA, ymmB, ymmC); 2823 e->vpshufb(ymmA, ymmB, anyptr_gpC); 2824 e->vpshufb(ymmA, ymmB, ymmC); 2825 e->vpsignb(ymmA, ymmB, anyptr_gpC); 2826 e->vpsignb(ymmA, ymmB, ymmC); 2827 e->vpsignd(ymmA, ymmB, anyptr_gpC); 2828 e->vpsignd(ymmA, ymmB, ymmC); 2829 e->vpsignw(ymmA, ymmB, anyptr_gpC); 2830 e->vpsignw(ymmA, ymmB, ymmC); 2831 e->vpslld(ymmA, ymmB, anyptr_gpC); 2832 e->vpslld(ymmA, ymmB, xmmC); 2833 e->vpsllq(ymmA, ymmB, anyptr_gpC); 2834 e->vpsllq(ymmA, ymmB, xmmC); 2835 e->vpsllvd(xmmA, xmmB, anyptr_gpC); 2836 e->vpsllvd(xmmA, xmmB, xmmC); 2837 e->vpsllvd(ymmA, ymmB, anyptr_gpC); 2838 e->vpsllvd(ymmA, ymmB, ymmC); 2839 e->vpsllvq(xmmA, xmmB, anyptr_gpC); 2840 e->vpsllvq(xmmA, xmmB, xmmC); 2841 e->vpsllvq(ymmA, ymmB, anyptr_gpC); 2842 e->vpsllvq(ymmA, ymmB, ymmC); 2843 e->vpsllw(ymmA, ymmB, anyptr_gpC); 2844 e->vpsllw(ymmA, ymmB, xmmC); 2845 e->vpsrad(ymmA, ymmB, anyptr_gpC); 2846 e->vpsrad(ymmA, ymmB, xmmC); 2847 e->vpsravd(xmmA, xmmB, anyptr_gpC); 2848 e->vpsravd(xmmA, xmmB, xmmC); 2849 e->vpsravd(ymmA, ymmB, anyptr_gpC); 2850 e->vpsravd(ymmA, ymmB, ymmC); 2851 e->vpsraw(ymmA, ymmB, anyptr_gpC); 2852 e->vpsraw(ymmA, ymmB, xmmC); 2853 e->vpsrld(ymmA, ymmB, anyptr_gpC); 2854 e->vpsrld(ymmA, ymmB, xmmC); 2855 e->vpsrlq(ymmA, ymmB, anyptr_gpC); 2856 e->vpsrlq(ymmA, ymmB, xmmC); 2857 e->vpsrlvd(xmmA, xmmB, anyptr_gpC); 2858 e->vpsrlvd(xmmA, xmmB, xmmC); 2859 e->vpsrlvd(ymmA, ymmB, anyptr_gpC); 2860 e->vpsrlvd(ymmA, ymmB, ymmC); 2861 e->vpsrlvq(xmmA, xmmB, anyptr_gpC); 2862 e->vpsrlvq(xmmA, xmmB, xmmC); 2863 e->vpsrlvq(ymmA, ymmB, anyptr_gpC); 2864 e->vpsrlvq(ymmA, ymmB, ymmC); 2865 e->vpsrlw(ymmA, ymmB, anyptr_gpC); 2866 e->vpsrlw(ymmA, ymmB, xmmC); 2867 e->vpsubb(ymmA, ymmB, anyptr_gpC); 2868 e->vpsubb(ymmA, ymmB, ymmC); 2869 e->vpsubd(ymmA, ymmB, anyptr_gpC); 2870 e->vpsubd(ymmA, ymmB, ymmC); 2871 e->vpsubq(ymmA, ymmB, anyptr_gpC); 2872 e->vpsubq(ymmA, ymmB, ymmC); 2873 e->vpsubsb(ymmA, ymmB, anyptr_gpC); 2874 e->vpsubsb(ymmA, ymmB, ymmC); 2875 e->vpsubsw(ymmA, ymmB, anyptr_gpC); 2876 e->vpsubsw(ymmA, ymmB, ymmC); 2877 e->vpsubusb(ymmA, ymmB, anyptr_gpC); 2878 e->vpsubusb(ymmA, ymmB, ymmC); 2879 e->vpsubusw(ymmA, ymmB, anyptr_gpC); 2880 e->vpsubusw(ymmA, ymmB, ymmC); 2881 e->vpsubw(ymmA, ymmB, anyptr_gpC); 2882 e->vpsubw(ymmA, ymmB, ymmC); 2883 e->vpunpckhbw(ymmA, ymmB, anyptr_gpC); 2884 e->vpunpckhbw(ymmA, ymmB, ymmC); 2885 e->vpunpckhdq(ymmA, ymmB, anyptr_gpC); 2886 e->vpunpckhdq(ymmA, ymmB, ymmC); 2887 e->vpunpckhqdq(ymmA, ymmB, anyptr_gpC); 2888 e->vpunpckhqdq(ymmA, ymmB, ymmC); 2889 e->vpunpckhwd(ymmA, ymmB, anyptr_gpC); 2890 e->vpunpckhwd(ymmA, ymmB, ymmC); 2891 e->vpunpcklbw(ymmA, ymmB, anyptr_gpC); 2892 e->vpunpcklbw(ymmA, ymmB, ymmC); 2893 e->vpunpckldq(ymmA, ymmB, anyptr_gpC); 2894 e->vpunpckldq(ymmA, ymmB, ymmC); 2895 e->vpunpcklqdq(ymmA, ymmB, anyptr_gpC); 2896 e->vpunpcklqdq(ymmA, ymmB, ymmC); 2897 e->vpunpcklwd(ymmA, ymmB, anyptr_gpC); 2898 e->vpunpcklwd(ymmA, ymmB, ymmC); 2899 e->vpxor(ymmA, ymmB, anyptr_gpC); 2900 e->vpxor(ymmA, ymmB, ymmC); 2901 2902 // FMA. 2903 e->nop(); 2904 2905 e->vfmadd132pd(xmmA, xmmB, anyptr_gpC); 2906 e->vfmadd132pd(xmmA, xmmB, xmmC); 2907 e->vfmadd132pd(ymmA, ymmB, anyptr_gpC); 2908 e->vfmadd132pd(ymmA, ymmB, ymmC); 2909 e->vfmadd132ps(xmmA, xmmB, anyptr_gpC); 2910 e->vfmadd132ps(xmmA, xmmB, xmmC); 2911 e->vfmadd132ps(ymmA, ymmB, anyptr_gpC); 2912 e->vfmadd132ps(ymmA, ymmB, ymmC); 2913 e->vfmadd132sd(xmmA, xmmB, anyptr_gpC); 2914 e->vfmadd132sd(xmmA, xmmB, xmmC); 2915 e->vfmadd132ss(xmmA, xmmB, anyptr_gpC); 2916 e->vfmadd132ss(xmmA, xmmB, xmmC); 2917 e->vfmadd213pd(xmmA, xmmB, anyptr_gpC); 2918 e->vfmadd213pd(xmmA, xmmB, xmmC); 2919 e->vfmadd213pd(ymmA, ymmB, anyptr_gpC); 2920 e->vfmadd213pd(ymmA, ymmB, ymmC); 2921 e->vfmadd213ps(xmmA, xmmB, anyptr_gpC); 2922 e->vfmadd213ps(xmmA, xmmB, xmmC); 2923 e->vfmadd213ps(ymmA, ymmB, anyptr_gpC); 2924 e->vfmadd213ps(ymmA, ymmB, ymmC); 2925 e->vfmadd213sd(xmmA, xmmB, anyptr_gpC); 2926 e->vfmadd213sd(xmmA, xmmB, xmmC); 2927 e->vfmadd213ss(xmmA, xmmB, anyptr_gpC); 2928 e->vfmadd213ss(xmmA, xmmB, xmmC); 2929 e->vfmadd231pd(xmmA, xmmB, anyptr_gpC); 2930 e->vfmadd231pd(xmmA, xmmB, xmmC); 2931 e->vfmadd231pd(ymmA, ymmB, anyptr_gpC); 2932 e->vfmadd231pd(ymmA, ymmB, ymmC); 2933 e->vfmadd231ps(xmmA, xmmB, anyptr_gpC); 2934 e->vfmadd231ps(xmmA, xmmB, xmmC); 2935 e->vfmadd231ps(ymmA, ymmB, anyptr_gpC); 2936 e->vfmadd231ps(ymmA, ymmB, ymmC); 2937 e->vfmadd231sd(xmmA, xmmB, anyptr_gpC); 2938 e->vfmadd231sd(xmmA, xmmB, xmmC); 2939 e->vfmadd231ss(xmmA, xmmB, anyptr_gpC); 2940 e->vfmadd231ss(xmmA, xmmB, xmmC); 2941 e->vfmaddsub132pd(xmmA, xmmB, anyptr_gpC); 2942 e->vfmaddsub132pd(xmmA, xmmB, xmmC); 2943 e->vfmaddsub132pd(ymmA, ymmB, anyptr_gpC); 2944 e->vfmaddsub132pd(ymmA, ymmB, ymmC); 2945 e->vfmaddsub132ps(xmmA, xmmB, anyptr_gpC); 2946 e->vfmaddsub132ps(xmmA, xmmB, xmmC); 2947 e->vfmaddsub132ps(ymmA, ymmB, anyptr_gpC); 2948 e->vfmaddsub132ps(ymmA, ymmB, ymmC); 2949 e->vfmaddsub213pd(xmmA, xmmB, anyptr_gpC); 2950 e->vfmaddsub213pd(xmmA, xmmB, xmmC); 2951 e->vfmaddsub213pd(ymmA, ymmB, anyptr_gpC); 2952 e->vfmaddsub213pd(ymmA, ymmB, ymmC); 2953 e->vfmaddsub213ps(xmmA, xmmB, anyptr_gpC); 2954 e->vfmaddsub213ps(xmmA, xmmB, xmmC); 2955 e->vfmaddsub213ps(ymmA, ymmB, anyptr_gpC); 2956 e->vfmaddsub213ps(ymmA, ymmB, ymmC); 2957 e->vfmaddsub231pd(xmmA, xmmB, anyptr_gpC); 2958 e->vfmaddsub231pd(xmmA, xmmB, xmmC); 2959 e->vfmaddsub231pd(ymmA, ymmB, anyptr_gpC); 2960 e->vfmaddsub231pd(ymmA, ymmB, ymmC); 2961 e->vfmaddsub231ps(xmmA, xmmB, anyptr_gpC); 2962 e->vfmaddsub231ps(xmmA, xmmB, xmmC); 2963 e->vfmaddsub231ps(ymmA, ymmB, anyptr_gpC); 2964 e->vfmaddsub231ps(ymmA, ymmB, ymmC); 2965 e->vfmsub132pd(xmmA, xmmB, anyptr_gpC); 2966 e->vfmsub132pd(xmmA, xmmB, xmmC); 2967 e->vfmsub132pd(ymmA, ymmB, anyptr_gpC); 2968 e->vfmsub132pd(ymmA, ymmB, ymmC); 2969 e->vfmsub132ps(xmmA, xmmB, anyptr_gpC); 2970 e->vfmsub132ps(xmmA, xmmB, xmmC); 2971 e->vfmsub132ps(ymmA, ymmB, anyptr_gpC); 2972 e->vfmsub132ps(ymmA, ymmB, ymmC); 2973 e->vfmsub132sd(xmmA, xmmB, anyptr_gpC); 2974 e->vfmsub132sd(xmmA, xmmB, xmmC); 2975 e->vfmsub132ss(xmmA, xmmB, anyptr_gpC); 2976 e->vfmsub132ss(xmmA, xmmB, xmmC); 2977 e->vfmsub213pd(xmmA, xmmB, anyptr_gpC); 2978 e->vfmsub213pd(xmmA, xmmB, xmmC); 2979 e->vfmsub213pd(ymmA, ymmB, anyptr_gpC); 2980 e->vfmsub213pd(ymmA, ymmB, ymmC); 2981 e->vfmsub213ps(xmmA, xmmB, anyptr_gpC); 2982 e->vfmsub213ps(xmmA, xmmB, xmmC); 2983 e->vfmsub213ps(ymmA, ymmB, anyptr_gpC); 2984 e->vfmsub213ps(ymmA, ymmB, ymmC); 2985 e->vfmsub213sd(xmmA, xmmB, anyptr_gpC); 2986 e->vfmsub213sd(xmmA, xmmB, xmmC); 2987 e->vfmsub213ss(xmmA, xmmB, anyptr_gpC); 2988 e->vfmsub213ss(xmmA, xmmB, xmmC); 2989 e->vfmsub231pd(xmmA, xmmB, anyptr_gpC); 2990 e->vfmsub231pd(xmmA, xmmB, xmmC); 2991 e->vfmsub231pd(ymmA, ymmB, anyptr_gpC); 2992 e->vfmsub231pd(ymmA, ymmB, ymmC); 2993 e->vfmsub231ps(xmmA, xmmB, anyptr_gpC); 2994 e->vfmsub231ps(xmmA, xmmB, xmmC); 2995 e->vfmsub231ps(ymmA, ymmB, anyptr_gpC); 2996 e->vfmsub231ps(ymmA, ymmB, ymmC); 2997 e->vfmsub231sd(xmmA, xmmB, anyptr_gpC); 2998 e->vfmsub231sd(xmmA, xmmB, xmmC); 2999 e->vfmsub231ss(xmmA, xmmB, anyptr_gpC); 3000 e->vfmsub231ss(xmmA, xmmB, xmmC); 3001 e->vfmsubadd132pd(xmmA, xmmB, anyptr_gpC); 3002 e->vfmsubadd132pd(xmmA, xmmB, xmmC); 3003 e->vfmsubadd132pd(ymmA, ymmB, anyptr_gpC); 3004 e->vfmsubadd132pd(ymmA, ymmB, ymmC); 3005 e->vfmsubadd132ps(xmmA, xmmB, anyptr_gpC); 3006 e->vfmsubadd132ps(xmmA, xmmB, xmmC); 3007 e->vfmsubadd132ps(ymmA, ymmB, anyptr_gpC); 3008 e->vfmsubadd132ps(ymmA, ymmB, ymmC); 3009 e->vfmsubadd213pd(xmmA, xmmB, anyptr_gpC); 3010 e->vfmsubadd213pd(xmmA, xmmB, xmmC); 3011 e->vfmsubadd213pd(ymmA, ymmB, anyptr_gpC); 3012 e->vfmsubadd213pd(ymmA, ymmB, ymmC); 3013 e->vfmsubadd213ps(xmmA, xmmB, anyptr_gpC); 3014 e->vfmsubadd213ps(xmmA, xmmB, xmmC); 3015 e->vfmsubadd213ps(ymmA, ymmB, anyptr_gpC); 3016 e->vfmsubadd213ps(ymmA, ymmB, ymmC); 3017 e->vfmsubadd231pd(xmmA, xmmB, anyptr_gpC); 3018 e->vfmsubadd231pd(xmmA, xmmB, xmmC); 3019 e->vfmsubadd231pd(ymmA, ymmB, anyptr_gpC); 3020 e->vfmsubadd231pd(ymmA, ymmB, ymmC); 3021 e->vfmsubadd231ps(xmmA, xmmB, anyptr_gpC); 3022 e->vfmsubadd231ps(xmmA, xmmB, xmmC); 3023 e->vfmsubadd231ps(ymmA, ymmB, anyptr_gpC); 3024 e->vfmsubadd231ps(ymmA, ymmB, ymmC); 3025 e->vfnmadd132pd(xmmA, xmmB, anyptr_gpC); 3026 e->vfnmadd132pd(xmmA, xmmB, xmmC); 3027 e->vfnmadd132pd(ymmA, ymmB, anyptr_gpC); 3028 e->vfnmadd132pd(ymmA, ymmB, ymmC); 3029 e->vfnmadd132ps(xmmA, xmmB, anyptr_gpC); 3030 e->vfnmadd132ps(xmmA, xmmB, xmmC); 3031 e->vfnmadd132ps(ymmA, ymmB, anyptr_gpC); 3032 e->vfnmadd132ps(ymmA, ymmB, ymmC); 3033 e->vfnmadd132sd(xmmA, xmmB, anyptr_gpC); 3034 e->vfnmadd132sd(xmmA, xmmB, xmmC); 3035 e->vfnmadd132ss(xmmA, xmmB, anyptr_gpC); 3036 e->vfnmadd132ss(xmmA, xmmB, xmmC); 3037 e->vfnmadd213pd(xmmA, xmmB, anyptr_gpC); 3038 e->vfnmadd213pd(xmmA, xmmB, xmmC); 3039 e->vfnmadd213pd(ymmA, ymmB, anyptr_gpC); 3040 e->vfnmadd213pd(ymmA, ymmB, ymmC); 3041 e->vfnmadd213ps(xmmA, xmmB, anyptr_gpC); 3042 e->vfnmadd213ps(xmmA, xmmB, xmmC); 3043 e->vfnmadd213ps(ymmA, ymmB, anyptr_gpC); 3044 e->vfnmadd213ps(ymmA, ymmB, ymmC); 3045 e->vfnmadd213sd(xmmA, xmmB, anyptr_gpC); 3046 e->vfnmadd213sd(xmmA, xmmB, xmmC); 3047 e->vfnmadd213ss(xmmA, xmmB, anyptr_gpC); 3048 e->vfnmadd213ss(xmmA, xmmB, xmmC); 3049 e->vfnmadd231pd(xmmA, xmmB, anyptr_gpC); 3050 e->vfnmadd231pd(xmmA, xmmB, xmmC); 3051 e->vfnmadd231pd(ymmA, ymmB, anyptr_gpC); 3052 e->vfnmadd231pd(ymmA, ymmB, ymmC); 3053 e->vfnmadd231ps(xmmA, xmmB, anyptr_gpC); 3054 e->vfnmadd231ps(xmmA, xmmB, xmmC); 3055 e->vfnmadd231ps(ymmA, ymmB, anyptr_gpC); 3056 e->vfnmadd231ps(ymmA, ymmB, ymmC); 3057 e->vfnmadd231sd(xmmA, xmmB, anyptr_gpC); 3058 e->vfnmadd231sd(xmmA, xmmB, xmmC); 3059 e->vfnmadd231ss(xmmA, xmmB, anyptr_gpC); 3060 e->vfnmadd231ss(xmmA, xmmB, xmmC); 3061 e->vfnmsub132pd(xmmA, xmmB, anyptr_gpC); 3062 e->vfnmsub132pd(xmmA, xmmB, xmmC); 3063 e->vfnmsub132pd(ymmA, ymmB, anyptr_gpC); 3064 e->vfnmsub132pd(ymmA, ymmB, ymmC); 3065 e->vfnmsub132ps(xmmA, xmmB, anyptr_gpC); 3066 e->vfnmsub132ps(xmmA, xmmB, xmmC); 3067 e->vfnmsub132ps(ymmA, ymmB, anyptr_gpC); 3068 e->vfnmsub132ps(ymmA, ymmB, ymmC); 3069 e->vfnmsub132sd(xmmA, xmmB, anyptr_gpC); 3070 e->vfnmsub132sd(xmmA, xmmB, xmmC); 3071 e->vfnmsub132ss(xmmA, xmmB, anyptr_gpC); 3072 e->vfnmsub132ss(xmmA, xmmB, xmmC); 3073 e->vfnmsub213pd(xmmA, xmmB, anyptr_gpC); 3074 e->vfnmsub213pd(xmmA, xmmB, xmmC); 3075 e->vfnmsub213pd(ymmA, ymmB, anyptr_gpC); 3076 e->vfnmsub213pd(ymmA, ymmB, ymmC); 3077 e->vfnmsub213ps(xmmA, xmmB, anyptr_gpC); 3078 e->vfnmsub213ps(xmmA, xmmB, xmmC); 3079 e->vfnmsub213ps(ymmA, ymmB, anyptr_gpC); 3080 e->vfnmsub213ps(ymmA, ymmB, ymmC); 3081 e->vfnmsub213sd(xmmA, xmmB, anyptr_gpC); 3082 e->vfnmsub213sd(xmmA, xmmB, xmmC); 3083 e->vfnmsub213ss(xmmA, xmmB, anyptr_gpC); 3084 e->vfnmsub213ss(xmmA, xmmB, xmmC); 3085 e->vfnmsub231pd(xmmA, xmmB, anyptr_gpC); 3086 e->vfnmsub231pd(xmmA, xmmB, xmmC); 3087 e->vfnmsub231pd(ymmA, ymmB, anyptr_gpC); 3088 e->vfnmsub231pd(ymmA, ymmB, ymmC); 3089 e->vfnmsub231ps(xmmA, xmmB, anyptr_gpC); 3090 e->vfnmsub231ps(xmmA, xmmB, xmmC); 3091 e->vfnmsub231ps(ymmA, ymmB, anyptr_gpC); 3092 e->vfnmsub231ps(ymmA, ymmB, ymmC); 3093 e->vfnmsub231sd(xmmA, xmmB, anyptr_gpC); 3094 e->vfnmsub231sd(xmmA, xmmB, xmmC); 3095 e->vfnmsub231ss(xmmA, xmmB, anyptr_gpC); 3096 e->vfnmsub231ss(xmmA, xmmB, xmmC); 3097 3098 // FMA4. 3099 e->nop(); 3100 3101 e->vfmaddpd(xmmA, xmmB, xmmC, xmmD); 3102 e->vfmaddpd(xmmA, xmmB, anyptr_gpC, xmmD); 3103 e->vfmaddpd(xmmA, xmmB, xmmC, anyptr_gpD); 3104 e->vfmaddpd(ymmA, ymmB, ymmC, ymmD); 3105 e->vfmaddpd(ymmA, ymmB, anyptr_gpC, ymmD); 3106 e->vfmaddpd(ymmA, ymmB, ymmC, anyptr_gpD); 3107 e->vfmaddps(xmmA, xmmB, xmmC, xmmD); 3108 e->vfmaddps(xmmA, xmmB, anyptr_gpC, xmmD); 3109 e->vfmaddps(xmmA, xmmB, xmmC, anyptr_gpD); 3110 e->vfmaddps(ymmA, ymmB, ymmC, ymmD); 3111 e->vfmaddps(ymmA, ymmB, anyptr_gpC, ymmD); 3112 e->vfmaddps(ymmA, ymmB, ymmC, anyptr_gpD); 3113 e->vfmaddsd(xmmA, xmmB, xmmC, xmmD); 3114 e->vfmaddsd(xmmA, xmmB, anyptr_gpC, xmmD); 3115 e->vfmaddsd(xmmA, xmmB, xmmC, anyptr_gpD); 3116 e->vfmaddss(xmmA, xmmB, xmmC, xmmD); 3117 e->vfmaddss(xmmA, xmmB, anyptr_gpC, xmmD); 3118 e->vfmaddss(xmmA, xmmB, xmmC, anyptr_gpD); 3119 e->vfmaddsubpd(xmmA, xmmB, xmmC, xmmD); 3120 e->vfmaddsubpd(xmmA, xmmB, anyptr_gpC, xmmD); 3121 e->vfmaddsubpd(xmmA, xmmB, xmmC, anyptr_gpD); 3122 e->vfmaddsubpd(ymmA, ymmB, ymmC, ymmD); 3123 e->vfmaddsubpd(ymmA, ymmB, anyptr_gpC, ymmD); 3124 e->vfmaddsubpd(ymmA, ymmB, ymmC, anyptr_gpD); 3125 e->vfmaddsubps(xmmA, xmmB, xmmC, xmmD); 3126 e->vfmaddsubps(xmmA, xmmB, anyptr_gpC, xmmD); 3127 e->vfmaddsubps(xmmA, xmmB, xmmC, anyptr_gpD); 3128 e->vfmaddsubps(ymmA, ymmB, ymmC, ymmD); 3129 e->vfmaddsubps(ymmA, ymmB, anyptr_gpC, ymmD); 3130 e->vfmaddsubps(ymmA, ymmB, ymmC, anyptr_gpD); 3131 e->vfmsubaddpd(xmmA, xmmB, xmmC, xmmD); 3132 e->vfmsubaddpd(xmmA, xmmB, anyptr_gpC, xmmD); 3133 e->vfmsubaddpd(xmmA, xmmB, xmmC, anyptr_gpD); 3134 e->vfmsubaddpd(ymmA, ymmB, ymmC, ymmD); 3135 e->vfmsubaddpd(ymmA, ymmB, anyptr_gpC, ymmD); 3136 e->vfmsubaddpd(ymmA, ymmB, ymmC, anyptr_gpD); 3137 e->vfmsubaddps(xmmA, xmmB, xmmC, xmmD); 3138 e->vfmsubaddps(xmmA, xmmB, anyptr_gpC, xmmD); 3139 e->vfmsubaddps(xmmA, xmmB, xmmC, anyptr_gpD); 3140 e->vfmsubaddps(ymmA, ymmB, ymmC, ymmD); 3141 e->vfmsubaddps(ymmA, ymmB, anyptr_gpC, ymmD); 3142 e->vfmsubaddps(ymmA, ymmB, ymmC, anyptr_gpD); 3143 e->vfmsubpd(xmmA, xmmB, xmmC, xmmD); 3144 e->vfmsubpd(xmmA, xmmB, anyptr_gpC, xmmD); 3145 e->vfmsubpd(xmmA, xmmB, xmmC, anyptr_gpD); 3146 e->vfmsubpd(ymmA, ymmB, ymmC, ymmD); 3147 e->vfmsubpd(ymmA, ymmB, anyptr_gpC, ymmD); 3148 e->vfmsubpd(ymmA, ymmB, ymmC, anyptr_gpD); 3149 e->vfmsubps(xmmA, xmmB, xmmC, xmmD); 3150 e->vfmsubps(xmmA, xmmB, anyptr_gpC, xmmD); 3151 e->vfmsubps(xmmA, xmmB, xmmC, anyptr_gpD); 3152 e->vfmsubps(ymmA, ymmB, ymmC, ymmD); 3153 e->vfmsubps(ymmA, ymmB, anyptr_gpC, ymmD); 3154 e->vfmsubps(ymmA, ymmB, ymmC, anyptr_gpD); 3155 e->vfmsubsd(xmmA, xmmB, xmmC, xmmD); 3156 e->vfmsubsd(xmmA, xmmB, anyptr_gpC, xmmD); 3157 e->vfmsubsd(xmmA, xmmB, xmmC, anyptr_gpD); 3158 e->vfmsubss(xmmA, xmmB, xmmC, xmmD); 3159 e->vfmsubss(xmmA, xmmB, anyptr_gpC, xmmD); 3160 e->vfmsubss(xmmA, xmmB, xmmC, anyptr_gpD); 3161 e->vfnmaddpd(xmmA, xmmB, xmmC, xmmD); 3162 e->vfnmaddpd(xmmA, xmmB, anyptr_gpC, xmmD); 3163 e->vfnmaddpd(xmmA, xmmB, xmmC, anyptr_gpD); 3164 e->vfnmaddpd(ymmA, ymmB, ymmC, ymmD); 3165 e->vfnmaddpd(ymmA, ymmB, anyptr_gpC, ymmD); 3166 e->vfnmaddpd(ymmA, ymmB, ymmC, anyptr_gpD); 3167 e->vfnmaddps(xmmA, xmmB, xmmC, xmmD); 3168 e->vfnmaddps(xmmA, xmmB, anyptr_gpC, xmmD); 3169 e->vfnmaddps(xmmA, xmmB, xmmC, anyptr_gpD); 3170 e->vfnmaddps(ymmA, ymmB, ymmC, ymmD); 3171 e->vfnmaddps(ymmA, ymmB, anyptr_gpC, ymmD); 3172 e->vfnmaddps(ymmA, ymmB, ymmC, anyptr_gpD); 3173 e->vfnmaddsd(xmmA, xmmB, xmmC, xmmD); 3174 e->vfnmaddsd(xmmA, xmmB, anyptr_gpC, xmmD); 3175 e->vfnmaddsd(xmmA, xmmB, xmmC, anyptr_gpD); 3176 e->vfnmaddss(xmmA, xmmB, xmmC, xmmD); 3177 e->vfnmaddss(xmmA, xmmB, anyptr_gpC, xmmD); 3178 e->vfnmaddss(xmmA, xmmB, xmmC, anyptr_gpD); 3179 e->vfnmsubpd(xmmA, xmmB, xmmC, xmmD); 3180 e->vfnmsubpd(xmmA, xmmB, anyptr_gpC, xmmD); 3181 e->vfnmsubpd(xmmA, xmmB, xmmC, anyptr_gpD); 3182 e->vfnmsubpd(ymmA, ymmB, ymmC, ymmD); 3183 e->vfnmsubpd(ymmA, ymmB, anyptr_gpC, ymmD); 3184 e->vfnmsubpd(ymmA, ymmB, ymmC, anyptr_gpD); 3185 e->vfnmsubps(xmmA, xmmB, xmmC, xmmD); 3186 e->vfnmsubps(xmmA, xmmB, anyptr_gpC, xmmD); 3187 e->vfnmsubps(xmmA, xmmB, xmmC, anyptr_gpD); 3188 e->vfnmsubps(ymmA, ymmB, ymmC, ymmD); 3189 e->vfnmsubps(ymmA, ymmB, anyptr_gpC, ymmD); 3190 e->vfnmsubps(ymmA, ymmB, ymmC, anyptr_gpD); 3191 e->vfnmsubsd(xmmA, xmmB, xmmC, xmmD); 3192 e->vfnmsubsd(xmmA, xmmB, anyptr_gpC, xmmD); 3193 e->vfnmsubsd(xmmA, xmmB, xmmC, anyptr_gpD); 3194 e->vfnmsubss(xmmA, xmmB, xmmC, xmmD); 3195 e->vfnmsubss(xmmA, xmmB, anyptr_gpC, xmmD); 3196 e->vfnmsubss(xmmA, xmmB, xmmC, anyptr_gpD); 3197 3198 // XOP. 3199 e->nop(); 3200 3201 e->vfrczpd(xmmA, xmmB); 3202 e->vfrczpd(xmmA, anyptr_gpB); 3203 e->vfrczpd(ymmA, ymmB); 3204 e->vfrczpd(ymmA, anyptr_gpB); 3205 e->vfrczps(xmmA, xmmB); 3206 e->vfrczps(xmmA, anyptr_gpB); 3207 e->vfrczps(ymmA, ymmB); 3208 e->vfrczps(ymmA, anyptr_gpB); 3209 e->vfrczsd(xmmA, xmmB); 3210 e->vfrczsd(xmmA, anyptr_gpB); 3211 e->vfrczss(xmmA, xmmB); 3212 e->vfrczss(xmmA, anyptr_gpB); 3213 e->vpcmov(xmmA, xmmB, xmmC, xmmD); 3214 e->vpcmov(xmmA, xmmB, anyptr_gpC, xmmD); 3215 e->vpcmov(xmmA, xmmB, xmmC, anyptr_gpD); 3216 e->vpcmov(ymmA, ymmB, ymmC, ymmD); 3217 e->vpcmov(ymmA, ymmB, anyptr_gpC, ymmD); 3218 e->vpcmov(ymmA, ymmB, ymmC, anyptr_gpD); 3219 e->vpcomb(xmmA, xmmB, xmmC, 0); 3220 e->vpcomb(xmmA, xmmB, anyptr_gpC, 0); 3221 e->vpcomd(xmmA, xmmB, xmmC, 0); 3222 e->vpcomd(xmmA, xmmB, anyptr_gpC, 0); 3223 e->vpcomq(xmmA, xmmB, xmmC, 0); 3224 e->vpcomq(xmmA, xmmB, anyptr_gpC, 0); 3225 e->vpcomw(xmmA, xmmB, xmmC, 0); 3226 e->vpcomw(xmmA, xmmB, anyptr_gpC, 0); 3227 e->vpcomub(xmmA, xmmB, xmmC, 0); 3228 e->vpcomub(xmmA, xmmB, anyptr_gpC, 0); 3229 e->vpcomud(xmmA, xmmB, xmmC, 0); 3230 e->vpcomud(xmmA, xmmB, anyptr_gpC, 0); 3231 e->vpcomuq(xmmA, xmmB, xmmC, 0); 3232 e->vpcomuq(xmmA, xmmB, anyptr_gpC, 0); 3233 e->vpcomuw(xmmA, xmmB, xmmC, 0); 3234 e->vpcomuw(xmmA, xmmB, anyptr_gpC, 0); 3235 e->vpermil2pd(xmmA, xmmB, xmmC, xmmD, 0); 3236 e->vpermil2pd(xmmA, xmmB, anyptr_gpC, xmmD, 0); 3237 e->vpermil2pd(xmmA, xmmB, xmmC, anyptr_gpD, 0); 3238 e->vpermil2pd(ymmA, ymmB, ymmC, ymmD, 0); 3239 e->vpermil2pd(ymmA, ymmB, anyptr_gpC, ymmD, 0); 3240 e->vpermil2pd(ymmA, ymmB, ymmC, anyptr_gpD, 0); 3241 e->vpermil2ps(xmmA, xmmB, xmmC, xmmD, 0); 3242 e->vpermil2ps(xmmA, xmmB, anyptr_gpC, xmmD, 0); 3243 e->vpermil2ps(xmmA, xmmB, xmmC, anyptr_gpD, 0); 3244 e->vpermil2ps(ymmA, ymmB, ymmC, ymmD, 0); 3245 e->vpermil2ps(ymmA, ymmB, anyptr_gpC, ymmD, 0); 3246 e->vpermil2ps(ymmA, ymmB, ymmC, anyptr_gpD, 0); 3247 e->vphaddbd(xmmA, xmmB); 3248 e->vphaddbd(xmmA, anyptr_gpB); 3249 e->vphaddbq(xmmA, xmmB); 3250 e->vphaddbq(xmmA, anyptr_gpB); 3251 e->vphaddbw(xmmA, xmmB); 3252 e->vphaddbw(xmmA, anyptr_gpB); 3253 e->vphadddq(xmmA, xmmB); 3254 e->vphadddq(xmmA, anyptr_gpB); 3255 e->vphaddwd(xmmA, xmmB); 3256 e->vphaddwd(xmmA, anyptr_gpB); 3257 e->vphaddwq(xmmA, xmmB); 3258 e->vphaddwq(xmmA, anyptr_gpB); 3259 e->vphaddubd(xmmA, xmmB); 3260 e->vphaddubd(xmmA, anyptr_gpB); 3261 e->vphaddubq(xmmA, xmmB); 3262 e->vphaddubq(xmmA, anyptr_gpB); 3263 e->vphaddubw(xmmA, xmmB); 3264 e->vphaddubw(xmmA, anyptr_gpB); 3265 e->vphaddudq(xmmA, xmmB); 3266 e->vphaddudq(xmmA, anyptr_gpB); 3267 e->vphadduwd(xmmA, xmmB); 3268 e->vphadduwd(xmmA, anyptr_gpB); 3269 e->vphadduwq(xmmA, xmmB); 3270 e->vphadduwq(xmmA, anyptr_gpB); 3271 e->vphsubbw(xmmA, xmmB); 3272 e->vphsubbw(xmmA, anyptr_gpB); 3273 e->vphsubdq(xmmA, xmmB); 3274 e->vphsubdq(xmmA, anyptr_gpB); 3275 e->vphsubwd(xmmA, xmmB); 3276 e->vphsubwd(xmmA, anyptr_gpB); 3277 e->vpmacsdd(xmmA, xmmB, xmmC, xmmD); 3278 e->vpmacsdd(xmmA, xmmB, anyptr_gpC, xmmD); 3279 e->vpmacsdqh(xmmA, xmmB, xmmC, xmmD); 3280 e->vpmacsdqh(xmmA, xmmB, anyptr_gpC, xmmD); 3281 e->vpmacsdql(xmmA, xmmB, xmmC, xmmD); 3282 e->vpmacsdql(xmmA, xmmB, anyptr_gpC, xmmD); 3283 e->vpmacswd(xmmA, xmmB, xmmC, xmmD); 3284 e->vpmacswd(xmmA, xmmB, anyptr_gpC, xmmD); 3285 e->vpmacsww(xmmA, xmmB, xmmC, xmmD); 3286 e->vpmacsww(xmmA, xmmB, anyptr_gpC, xmmD); 3287 e->vpmacssdd(xmmA, xmmB, xmmC, xmmD); 3288 e->vpmacssdd(xmmA, xmmB, anyptr_gpC, xmmD); 3289 e->vpmacssdqh(xmmA, xmmB, xmmC, xmmD); 3290 e->vpmacssdqh(xmmA, xmmB, anyptr_gpC, xmmD); 3291 e->vpmacssdql(xmmA, xmmB, xmmC, xmmD); 3292 e->vpmacssdql(xmmA, xmmB, anyptr_gpC, xmmD); 3293 e->vpmacsswd(xmmA, xmmB, xmmC, xmmD); 3294 e->vpmacsswd(xmmA, xmmB, anyptr_gpC, xmmD); 3295 e->vpmacssww(xmmA, xmmB, xmmC, xmmD); 3296 e->vpmacssww(xmmA, xmmB, anyptr_gpC, xmmD); 3297 e->vpmadcsswd(xmmA, xmmB, xmmC, xmmD); 3298 e->vpmadcsswd(xmmA, xmmB, anyptr_gpC, xmmD); 3299 e->vpmadcswd(xmmA, xmmB, xmmC, xmmD); 3300 e->vpmadcswd(xmmA, xmmB, anyptr_gpC, xmmD); 3301 e->vpperm(xmmA, xmmB, xmmC, xmmD); 3302 e->vpperm(xmmA, xmmB, anyptr_gpC, xmmD); 3303 e->vpperm(xmmA, xmmB, xmmC, anyptr_gpD); 3304 e->vprotb(xmmA, xmmB, xmmC); 3305 e->vprotb(xmmA, anyptr_gpB, xmmC); 3306 e->vprotb(xmmA, xmmB, anyptr_gpC); 3307 e->vprotb(xmmA, xmmB, 0); 3308 e->vprotb(xmmA, anyptr_gpB, 0); 3309 e->vprotd(xmmA, xmmB, xmmC); 3310 e->vprotd(xmmA, anyptr_gpB, xmmC); 3311 e->vprotd(xmmA, xmmB, anyptr_gpC); 3312 e->vprotd(xmmA, xmmB, 0); 3313 e->vprotd(xmmA, anyptr_gpB, 0); 3314 e->vprotq(xmmA, xmmB, xmmC); 3315 e->vprotq(xmmA, anyptr_gpB, xmmC); 3316 e->vprotq(xmmA, xmmB, anyptr_gpC); 3317 e->vprotq(xmmA, xmmB, 0); 3318 e->vprotq(xmmA, anyptr_gpB, 0); 3319 e->vprotw(xmmA, xmmB, xmmC); 3320 e->vprotw(xmmA, anyptr_gpB, xmmC); 3321 e->vprotw(xmmA, xmmB, anyptr_gpC); 3322 e->vprotw(xmmA, xmmB, 0); 3323 e->vprotw(xmmA, anyptr_gpB, 0); 3324 e->vpshab(xmmA, xmmB, xmmC); 3325 e->vpshab(xmmA, anyptr_gpB, xmmC); 3326 e->vpshab(xmmA, xmmB, anyptr_gpC); 3327 e->vpshad(xmmA, xmmB, xmmC); 3328 e->vpshad(xmmA, anyptr_gpB, xmmC); 3329 e->vpshad(xmmA, xmmB, anyptr_gpC); 3330 e->vpshaq(xmmA, xmmB, xmmC); 3331 e->vpshaq(xmmA, anyptr_gpB, xmmC); 3332 e->vpshaq(xmmA, xmmB, anyptr_gpC); 3333 e->vpshaw(xmmA, xmmB, xmmC); 3334 e->vpshaw(xmmA, anyptr_gpB, xmmC); 3335 e->vpshaw(xmmA, xmmB, anyptr_gpC); 3336 e->vpshlb(xmmA, xmmB, xmmC); 3337 e->vpshlb(xmmA, anyptr_gpB, xmmC); 3338 e->vpshlb(xmmA, xmmB, anyptr_gpC); 3339 e->vpshld(xmmA, xmmB, xmmC); 3340 e->vpshld(xmmA, anyptr_gpB, xmmC); 3341 e->vpshld(xmmA, xmmB, anyptr_gpC); 3342 e->vpshlq(xmmA, xmmB, xmmC); 3343 e->vpshlq(xmmA, anyptr_gpB, xmmC); 3344 e->vpshlq(xmmA, xmmB, anyptr_gpC); 3345 e->vpshlw(xmmA, xmmB, xmmC); 3346 e->vpshlw(xmmA, anyptr_gpB, xmmC); 3347 e->vpshlw(xmmA, xmmB, anyptr_gpC); 3348 3349 // F16C. 3350 e->nop(); 3351 3352 e->vcvtph2ps(xmmA, xmmB); 3353 e->vcvtph2ps(xmmA, anyptr_gpB); 3354 e->vcvtph2ps(ymmA, xmmB); 3355 e->vcvtph2ps(ymmA, anyptr_gpB); 3356 e->vcvtps2ph(xmmA, xmmB, 0); 3357 e->vcvtps2ph(anyptr_gpA, xmmB, 0); 3358 e->vcvtps2ph(xmmA, ymmB, 0); 3359 e->vcvtps2ph(anyptr_gpA, ymmB, 0); 3360 3361 // AVX512. 3362 e->nop(); 3363 3364 e->kaddb(kA, kB, kC); 3365 e->kaddd(kA, kB, kC); 3366 e->kaddq(kA, kB, kC); 3367 e->kaddw(kA, kB, kC); 3368 e->kandb(kA, kB, kC); 3369 e->kandd(kA, kB, kC); 3370 e->kandnb(kA, kB, kC); 3371 e->kandnd(kA, kB, kC); 3372 e->kandnq(kA, kB, kC); 3373 e->kandnw(kA, kB, kC); 3374 e->kandq(kA, kB, kC); 3375 e->kandw(kA, kB, kC); 3376 e->kmovb(kA, kB); 3377 e->kmovb(kA, anyptr_gpB); 3378 e->kmovb(kA, gdB); 3379 if (isX64) e->kmovb(kA, gzB); 3380 e->kmovb(anyptr_gpA, kB); 3381 e->kmovb(gdA, kB); 3382 if (isX64) e->kmovb(gzA, kB); 3383 e->kmovd(kA, kB); 3384 e->kmovd(kA, anyptr_gpB); 3385 e->kmovd(kA, gdB); 3386 if (isX64) e->kmovd(kA, gzB); 3387 e->kmovd(anyptr_gpA, kB); 3388 e->kmovd(gdA, kB); 3389 if (isX64) e->kmovd(gzA, kB); 3390 e->kmovq(kA, kB); 3391 e->kmovq(kA, anyptr_gpB); 3392 if (isX64) e->kmovq(kA, gzB); 3393 e->kmovq(anyptr_gpA, kB); 3394 if (isX64) e->kmovq(gzA, kB); 3395 e->kmovw(kA, kB); 3396 e->kmovw(kA, anyptr_gpB); 3397 e->kmovw(kA, gdB); 3398 if (isX64) e->kmovw(kA, gzB); 3399 e->kmovw(anyptr_gpA, kB); 3400 e->kmovw(gdA, kB); 3401 if (isX64) e->kmovw(gzA, kB); 3402 e->knotb(kA, kB); 3403 e->knotd(kA, kB); 3404 e->knotq(kA, kB); 3405 e->knotw(kA, kB); 3406 e->korb(kA, kB, kC); 3407 e->kord(kA, kB, kC); 3408 e->korq(kA, kB, kC); 3409 e->kortestb(kA, kB); 3410 e->kortestd(kA, kB); 3411 e->kortestq(kA, kB); 3412 e->kortestw(kA, kB); 3413 e->korw(kA, kB, kC); 3414 e->kshiftlb(kA, kB, 0); 3415 e->kshiftld(kA, kB, 0); 3416 e->kshiftlq(kA, kB, 0); 3417 e->kshiftlw(kA, kB, 0); 3418 e->kshiftrb(kA, kB, 0); 3419 e->kshiftrd(kA, kB, 0); 3420 e->kshiftrq(kA, kB, 0); 3421 e->kshiftrw(kA, kB, 0); 3422 e->ktestb(kA, kB); 3423 e->ktestd(kA, kB); 3424 e->ktestq(kA, kB); 3425 e->ktestw(kA, kB); 3426 e->kunpckbw(kA, kB, kC); 3427 e->kunpckdq(kA, kB, kC); 3428 e->kunpckwd(kA, kB, kC); 3429 e->kxnorb(kA, kB, kC); 3430 e->kxnord(kA, kB, kC); 3431 e->kxnorq(kA, kB, kC); 3432 e->kxnorw(kA, kB, kC); 3433 e->kxorb(kA, kB, kC); 3434 e->kxord(kA, kB, kC); 3435 e->kxorq(kA, kB, kC); 3436 e->kxorw(kA, kB, kC); 3437 e->nop(); 3438 3439 e->vaddpd(xmmA, xmmB, xmmC); 3440 e->vaddpd(xmmA, xmmB, anyptr_gpC); 3441 e->vaddpd(ymmA, ymmB, ymmC); 3442 e->vaddpd(ymmA, ymmB, anyptr_gpC); 3443 e->vaddpd(zmmA, zmmB, zmmC); 3444 e->vaddpd(zmmA, zmmB, anyptr_gpC); 3445 e->vaddps(xmmA, xmmB, xmmC); 3446 e->vaddps(xmmA, xmmB, anyptr_gpC); 3447 e->vaddps(ymmA, ymmB, ymmC); 3448 e->vaddps(ymmA, ymmB, anyptr_gpC); 3449 e->vaddps(zmmA, zmmB, zmmC); 3450 e->vaddps(zmmA, zmmB, anyptr_gpC); 3451 e->vaddsd(xmmA, xmmB, xmmC); 3452 e->vaddsd(xmmA, xmmB, anyptr_gpC); 3453 e->vaddss(xmmA, xmmB, xmmC); 3454 e->vaddss(xmmA, xmmB, anyptr_gpC); 3455 e->valignd(xmmA, xmmB, xmmC, 0); 3456 e->valignd(xmmA, xmmB, anyptr_gpC, 0); 3457 e->valignd(ymmA, ymmB, ymmC, 0); 3458 e->valignd(ymmA, ymmB, anyptr_gpC, 0); 3459 e->valignd(zmmA, zmmB, zmmC, 0); 3460 e->valignd(zmmA, zmmB, anyptr_gpC, 0); 3461 e->valignq(xmmA, xmmB, xmmC, 0); 3462 e->valignq(xmmA, xmmB, anyptr_gpC, 0); 3463 e->valignq(ymmA, ymmB, ymmC, 0); 3464 e->valignq(ymmA, ymmB, anyptr_gpC, 0); 3465 e->valignq(zmmA, zmmB, zmmC, 0); 3466 e->valignq(zmmA, zmmB, anyptr_gpC, 0); 3467 e->vandnpd(xmmA, xmmB, xmmC); 3468 e->vandnpd(xmmA, xmmB, anyptr_gpC); 3469 e->vandnpd(ymmA, ymmB, ymmC); 3470 e->vandnpd(ymmA, ymmB, anyptr_gpC); 3471 e->vandnpd(zmmA, zmmB, zmmC); 3472 e->vandnpd(zmmA, zmmB, anyptr_gpC); 3473 e->vandnps(xmmA, xmmB, xmmC); 3474 e->vandnps(xmmA, xmmB, anyptr_gpC); 3475 e->vandnps(ymmA, ymmB, ymmC); 3476 e->vandnps(ymmA, ymmB, anyptr_gpC); 3477 e->vandnps(zmmA, zmmB, zmmC); 3478 e->vandnps(zmmA, zmmB, anyptr_gpC); 3479 e->vandpd(xmmA, xmmB, xmmC); 3480 e->vandpd(xmmA, xmmB, anyptr_gpC); 3481 e->vandpd(ymmA, ymmB, ymmC); 3482 e->vandpd(ymmA, ymmB, anyptr_gpC); 3483 e->vandpd(zmmA, zmmB, zmmC); 3484 e->vandpd(zmmA, zmmB, anyptr_gpC); 3485 e->vandps(xmmA, xmmB, xmmC); 3486 e->vandps(xmmA, xmmB, anyptr_gpC); 3487 e->vandps(ymmA, ymmB, ymmC); 3488 e->vandps(ymmA, ymmB, anyptr_gpC); 3489 e->vandps(zmmA, zmmB, zmmC); 3490 e->vandps(zmmA, zmmB, anyptr_gpC); 3491 e->vblendmb(xmmA, xmmB, xmmC); 3492 e->vblendmb(xmmA, xmmB, anyptr_gpC); 3493 e->vblendmb(ymmA, ymmB, ymmC); 3494 e->vblendmb(ymmA, ymmB, anyptr_gpC); 3495 e->vblendmb(zmmA, zmmB, zmmC); 3496 e->vblendmb(zmmA, zmmB, anyptr_gpC); 3497 e->vblendmd(xmmA, xmmB, xmmC); 3498 e->vblendmd(xmmA, xmmB, anyptr_gpC); 3499 e->vblendmd(ymmA, ymmB, ymmC); 3500 e->vblendmd(ymmA, ymmB, anyptr_gpC); 3501 e->vblendmd(zmmA, zmmB, zmmC); 3502 e->vblendmd(zmmA, zmmB, anyptr_gpC); 3503 e->vblendmpd(xmmA, xmmB, xmmC); 3504 e->vblendmpd(xmmA, xmmB, anyptr_gpC); 3505 e->vblendmpd(ymmA, ymmB, ymmC); 3506 e->vblendmpd(ymmA, ymmB, anyptr_gpC); 3507 e->vblendmpd(zmmA, zmmB, zmmC); 3508 e->vblendmpd(zmmA, zmmB, anyptr_gpC); 3509 e->vblendmps(xmmA, xmmB, xmmC); 3510 e->vblendmps(xmmA, xmmB, anyptr_gpC); 3511 e->vblendmps(ymmA, ymmB, ymmC); 3512 e->vblendmps(ymmA, ymmB, anyptr_gpC); 3513 e->vblendmps(zmmA, zmmB, zmmC); 3514 e->vblendmps(zmmA, zmmB, anyptr_gpC); 3515 e->vblendmq(xmmA, xmmB, xmmC); 3516 e->vblendmq(xmmA, xmmB, anyptr_gpC); 3517 e->vblendmq(ymmA, ymmB, ymmC); 3518 e->vblendmq(ymmA, ymmB, anyptr_gpC); 3519 e->vblendmq(zmmA, zmmB, zmmC); 3520 e->vblendmq(zmmA, zmmB, anyptr_gpC); 3521 e->vblendmw(xmmA, xmmB, xmmC); 3522 e->vblendmw(xmmA, xmmB, anyptr_gpC); 3523 e->vblendmw(ymmA, ymmB, ymmC); 3524 e->vblendmw(ymmA, ymmB, anyptr_gpC); 3525 e->vblendmw(zmmA, zmmB, zmmC); 3526 e->vblendmw(zmmA, zmmB, anyptr_gpC); 3527 e->vbroadcastf32x2(ymmA, xmmB); 3528 e->vbroadcastf32x2(ymmA, anyptr_gpB); 3529 e->vbroadcastf32x2(zmmA, xmmB); 3530 e->vbroadcastf32x2(zmmA, anyptr_gpB); 3531 e->vbroadcastf32x4(ymmA, anyptr_gpB); 3532 e->vbroadcastf32x4(zmmA, anyptr_gpB); 3533 e->vbroadcastf32x8(zmmA, anyptr_gpB); 3534 e->vbroadcastf64x2(ymmA, anyptr_gpB); 3535 e->vbroadcastf64x2(zmmA, anyptr_gpB); 3536 e->vbroadcastf64x4(zmmA, anyptr_gpB); 3537 e->vbroadcasti32x2(xmmA, xmmB); 3538 e->vbroadcasti32x2(xmmA, anyptr_gpB); 3539 e->vbroadcasti32x2(ymmA, xmmB); 3540 e->vbroadcasti32x2(ymmA, anyptr_gpB); 3541 e->vbroadcasti32x2(zmmA, xmmB); 3542 e->vbroadcasti32x2(zmmA, anyptr_gpB); 3543 e->vbroadcasti32x4(ymmA, anyptr_gpB); 3544 e->vbroadcasti32x4(zmmA, anyptr_gpB); 3545 e->vbroadcasti32x8(zmmA, anyptr_gpB); 3546 e->vbroadcasti64x2(ymmA, anyptr_gpB); 3547 e->vbroadcasti64x2(zmmA, anyptr_gpB); 3548 e->vbroadcasti64x4(zmmA, anyptr_gpB); 3549 e->vbroadcastsd(ymmA, xmmB); 3550 e->vbroadcastsd(ymmA, anyptr_gpB); 3551 e->vbroadcastsd(zmmA, xmmB); 3552 e->vbroadcastsd(zmmA, anyptr_gpB); 3553 e->vbroadcastss(xmmA, xmmB); 3554 e->vbroadcastss(xmmA, anyptr_gpB); 3555 e->vbroadcastss(ymmA, xmmB); 3556 e->vbroadcastss(ymmA, anyptr_gpB); 3557 e->vbroadcastss(zmmA, xmmB); 3558 e->vbroadcastss(zmmA, anyptr_gpB); 3559 e->vcmppd(kA, xmmB, xmmC, 0); 3560 e->vcmppd(kA, xmmB, anyptr_gpC, 0); 3561 e->vcmppd(kA, ymmB, ymmC, 0); 3562 e->vcmppd(kA, ymmB, anyptr_gpC, 0); 3563 e->vcmppd(kA, zmmB, zmmC, 0); 3564 e->vcmppd(kA, zmmB, anyptr_gpC, 0); 3565 e->vcmpps(kA, xmmB, xmmC, 0); 3566 e->vcmpps(kA, xmmB, anyptr_gpC, 0); 3567 e->vcmpps(kA, ymmB, ymmC, 0); 3568 e->vcmpps(kA, ymmB, anyptr_gpC, 0); 3569 e->vcmpps(kA, zmmB, zmmC, 0); 3570 e->vcmpps(kA, zmmB, anyptr_gpC, 0); 3571 e->vcmpsd(kA, xmmB, xmmC, 0); 3572 e->vcmpsd(kA, xmmB, anyptr_gpC, 0); 3573 e->vcmpss(kA, xmmB, xmmC, 0); 3574 e->vcmpss(kA, xmmB, anyptr_gpC, 0); 3575 e->vcomisd(xmmA, xmmB); 3576 e->vcomisd(xmmA, anyptr_gpB); 3577 e->vcomiss(xmmA, xmmB); 3578 e->vcomiss(xmmA, anyptr_gpB); 3579 e->vcompresspd(xmmA, xmmB); 3580 e->vcompresspd(anyptr_gpA, xmmB); 3581 e->vcompresspd(ymmA, ymmB); 3582 e->vcompresspd(anyptr_gpA, ymmB); 3583 e->vcompresspd(zmmA, zmmB); 3584 e->vcompresspd(anyptr_gpA, zmmB); 3585 e->vcompressps(xmmA, xmmB); 3586 e->vcompressps(anyptr_gpA, xmmB); 3587 e->vcompressps(ymmA, ymmB); 3588 e->vcompressps(anyptr_gpA, ymmB); 3589 e->vcompressps(zmmA, zmmB); 3590 e->vcompressps(anyptr_gpA, zmmB); 3591 e->vcvtdq2pd(xmmA, xmmB); 3592 e->vcvtdq2pd(xmmA, anyptr_gpB); 3593 e->vcvtdq2pd(ymmA, xmmB); 3594 e->vcvtdq2pd(ymmA, anyptr_gpB); 3595 e->vcvtdq2pd(zmmA, ymmB); 3596 e->vcvtdq2pd(zmmA, anyptr_gpB); 3597 e->vcvtdq2ps(xmmA, xmmB); 3598 e->vcvtdq2ps(xmmA, anyptr_gpB); 3599 e->vcvtdq2ps(ymmA, ymmB); 3600 e->vcvtdq2ps(ymmA, anyptr_gpB); 3601 e->vcvtdq2ps(zmmA, zmmB); 3602 e->vcvtdq2ps(zmmA, anyptr_gpB); 3603 e->vcvtpd2dq(xmmA, xmmB); 3604 e->vcvtpd2dq(xmmA, anyptr_gpB); 3605 e->vcvtpd2dq(xmmA, ymmB); 3606 e->vcvtpd2dq(xmmA, anyptr_gpB); 3607 e->vcvtpd2dq(ymmA, zmmB); 3608 e->vcvtpd2dq(ymmA, anyptr_gpB); 3609 e->vcvtpd2qq(xmmA, xmmB); 3610 e->vcvtpd2qq(xmmA, anyptr_gpB); 3611 e->vcvtpd2qq(ymmA, ymmB); 3612 e->vcvtpd2qq(ymmA, anyptr_gpB); 3613 e->vcvtpd2qq(zmmA, zmmB); 3614 e->vcvtpd2qq(zmmA, anyptr_gpB); 3615 e->vcvtpd2udq(xmmA, xmmB); 3616 e->vcvtpd2udq(xmmA, anyptr_gpB); 3617 e->vcvtpd2udq(xmmA, ymmB); 3618 e->vcvtpd2udq(xmmA, anyptr_gpB); 3619 e->vcvtpd2udq(ymmA, zmmB); 3620 e->vcvtpd2udq(ymmA, anyptr_gpB); 3621 e->vcvtpd2uqq(xmmA, xmmB); 3622 e->vcvtpd2uqq(xmmA, anyptr_gpB); 3623 e->vcvtpd2uqq(ymmA, ymmB); 3624 e->vcvtpd2uqq(ymmA, anyptr_gpB); 3625 e->vcvtpd2uqq(zmmA, zmmB); 3626 e->vcvtpd2uqq(zmmA, anyptr_gpB); 3627 e->vcvtph2ps(xmmA, xmmB); 3628 e->vcvtph2ps(xmmA, anyptr_gpB); 3629 e->vcvtph2ps(ymmA, xmmB); 3630 e->vcvtph2ps(ymmA, anyptr_gpB); 3631 e->vcvtph2ps(zmmA, ymmB); 3632 e->vcvtph2ps(zmmA, anyptr_gpB); 3633 e->vcvtps2dq(xmmA, xmmB); 3634 e->vcvtps2dq(xmmA, anyptr_gpB); 3635 e->vcvtps2dq(ymmA, ymmB); 3636 e->vcvtps2dq(ymmA, anyptr_gpB); 3637 e->vcvtps2dq(zmmA, zmmB); 3638 e->vcvtps2dq(zmmA, anyptr_gpB); 3639 e->vcvtps2pd(xmmA, xmmB); 3640 e->vcvtps2pd(xmmA, anyptr_gpB); 3641 e->vcvtps2pd(ymmA, xmmB); 3642 e->vcvtps2pd(ymmA, anyptr_gpB); 3643 e->vcvtps2pd(zmmA, ymmB); 3644 e->vcvtps2pd(zmmA, anyptr_gpB); 3645 e->vcvtps2ph(xmmA, xmmB, 0); 3646 e->vcvtps2ph(anyptr_gpA, xmmB, 0); 3647 e->vcvtps2ph(xmmA, ymmB, 0); 3648 e->vcvtps2ph(anyptr_gpA, ymmB, 0); 3649 e->vcvtps2ph(ymmA, zmmB, 0); 3650 e->vcvtps2ph(anyptr_gpA, zmmB, 0); 3651 e->vcvtps2qq(xmmA, xmmB); 3652 e->vcvtps2qq(xmmA, anyptr_gpB); 3653 e->vcvtps2qq(ymmA, xmmB); 3654 e->vcvtps2qq(ymmA, anyptr_gpB); 3655 e->vcvtps2qq(zmmA, ymmB); 3656 e->vcvtps2qq(zmmA, anyptr_gpB); 3657 e->vcvtps2udq(xmmA, xmmB); 3658 e->vcvtps2udq(xmmA, anyptr_gpB); 3659 e->vcvtps2udq(ymmA, ymmB); 3660 e->vcvtps2udq(ymmA, anyptr_gpB); 3661 e->vcvtps2udq(zmmA, zmmB); 3662 e->vcvtps2udq(zmmA, anyptr_gpB); 3663 e->vcvtps2uqq(xmmA, xmmB); 3664 e->vcvtps2uqq(xmmA, anyptr_gpB); 3665 e->vcvtps2uqq(ymmA, xmmB); 3666 e->vcvtps2uqq(ymmA, anyptr_gpB); 3667 e->vcvtps2uqq(zmmA, ymmB); 3668 e->vcvtps2uqq(zmmA, anyptr_gpB); 3669 e->vcvtqq2pd(xmmA, xmmB); 3670 e->vcvtqq2pd(xmmA, anyptr_gpB); 3671 e->vcvtqq2pd(ymmA, ymmB); 3672 e->vcvtqq2pd(ymmA, anyptr_gpB); 3673 e->vcvtqq2pd(zmmA, zmmB); 3674 e->vcvtqq2pd(zmmA, anyptr_gpB); 3675 e->vcvtqq2ps(xmmA, xmmB); 3676 e->vcvtqq2ps(xmmA, anyptr_gpB); 3677 e->vcvtqq2ps(xmmA, ymmB); 3678 e->vcvtqq2ps(xmmA, anyptr_gpB); 3679 e->vcvtqq2ps(ymmA, zmmB); 3680 e->vcvtqq2ps(ymmA, anyptr_gpB); 3681 e->vcvtsd2si(gdA, xmmB); 3682 e->vcvtsd2si(gdA, anyptr_gpB); 3683 if (isX64) e->vcvtsd2si(gzA, xmmB); 3684 if (isX64) e->vcvtsd2si(gzA, anyptr_gpB); 3685 e->vcvtsd2ss(xmmA, xmmB, xmmC); 3686 e->vcvtsd2ss(xmmA, xmmB, anyptr_gpC); 3687 e->vcvtsd2usi(gdA, xmmB); 3688 e->vcvtsd2usi(gdA, anyptr_gpB); 3689 if (isX64) e->vcvtsd2usi(gzA, xmmB); 3690 if (isX64) e->vcvtsd2usi(gzA, anyptr_gpB); 3691 e->vcvtsi2sd(xmmA, xmmB, gdC); 3692 e->vcvtsi2sd(xmmA, xmmB, dword_ptr(gzC)); 3693 if (isX64) e->vcvtsi2sd(xmmA, xmmB, gzC); 3694 if (isX64) e->vcvtsi2sd(xmmA, xmmB, qword_ptr(gzC)); 3695 e->vcvtsi2ss(xmmA, xmmB, gdC); 3696 e->vcvtsi2ss(xmmA, xmmB, dword_ptr(gzC)); 3697 if (isX64) e->vcvtsi2ss(xmmA, xmmB, gzC); 3698 if (isX64) e->vcvtsi2ss(xmmA, xmmB, qword_ptr(gzC)); 3699 e->vcvtss2sd(xmmA, xmmB, xmmC); 3700 e->vcvtss2sd(xmmA, xmmB, anyptr_gpC); 3701 e->vcvtss2si(gdA, xmmB); 3702 e->vcvtss2si(gdA, anyptr_gpB); 3703 if (isX64) e->vcvtss2si(gzA, xmmB); 3704 if (isX64) e->vcvtss2si(gzA, anyptr_gpB); 3705 e->vcvtss2usi(gdA, xmmB); 3706 e->vcvtss2usi(gdA, anyptr_gpB); 3707 if (isX64) e->vcvtss2usi(gzA, xmmB); 3708 if (isX64) e->vcvtss2usi(gzA, anyptr_gpB); 3709 e->vcvttpd2dq(xmmA, xmmB); 3710 e->vcvttpd2dq(xmmA, anyptr_gpB); 3711 e->vcvttpd2dq(xmmA, ymmB); 3712 e->vcvttpd2dq(xmmA, anyptr_gpB); 3713 e->vcvttpd2dq(ymmA, zmmB); 3714 e->vcvttpd2dq(ymmA, anyptr_gpB); 3715 e->vcvttpd2qq(xmmA, xmmB); 3716 e->vcvttpd2qq(xmmA, anyptr_gpB); 3717 e->vcvttpd2qq(ymmA, ymmB); 3718 e->vcvttpd2qq(ymmA, anyptr_gpB); 3719 e->vcvttpd2qq(zmmA, zmmB); 3720 e->vcvttpd2qq(zmmA, anyptr_gpB); 3721 e->vcvttpd2udq(xmmA, xmmB); 3722 e->vcvttpd2udq(xmmA, anyptr_gpB); 3723 e->vcvttpd2udq(xmmA, ymmB); 3724 e->vcvttpd2udq(xmmA, anyptr_gpB); 3725 e->vcvttpd2udq(ymmA, zmmB); 3726 e->vcvttpd2udq(ymmA, anyptr_gpB); 3727 e->vcvttpd2uqq(xmmA, xmmB); 3728 e->vcvttpd2uqq(xmmA, anyptr_gpB); 3729 e->vcvttpd2uqq(ymmA, ymmB); 3730 e->vcvttpd2uqq(ymmA, anyptr_gpB); 3731 e->vcvttpd2uqq(zmmA, zmmB); 3732 e->vcvttpd2uqq(zmmA, anyptr_gpB); 3733 e->vcvttps2dq(xmmA, xmmB); 3734 e->vcvttps2dq(xmmA, anyptr_gpB); 3735 e->vcvttps2dq(ymmA, ymmB); 3736 e->vcvttps2dq(ymmA, anyptr_gpB); 3737 e->vcvttps2dq(zmmA, zmmB); 3738 e->vcvttps2dq(zmmA, anyptr_gpB); 3739 e->vcvttps2qq(xmmA, xmmB); 3740 e->vcvttps2qq(xmmA, anyptr_gpB); 3741 e->vcvttps2qq(ymmA, xmmB); 3742 e->vcvttps2qq(ymmA, anyptr_gpB); 3743 e->vcvttps2qq(zmmA, ymmB); 3744 e->vcvttps2qq(zmmA, anyptr_gpB); 3745 e->vcvttps2udq(xmmA, xmmB); 3746 e->vcvttps2udq(xmmA, anyptr_gpB); 3747 e->vcvttps2udq(ymmA, ymmB); 3748 e->vcvttps2udq(ymmA, anyptr_gpB); 3749 e->vcvttps2udq(zmmA, zmmB); 3750 e->vcvttps2udq(zmmA, anyptr_gpB); 3751 e->vcvttps2uqq(xmmA, xmmB); 3752 e->vcvttps2uqq(xmmA, anyptr_gpB); 3753 e->vcvttps2uqq(ymmA, xmmB); 3754 e->vcvttps2uqq(ymmA, anyptr_gpB); 3755 e->vcvttps2uqq(zmmA, ymmB); 3756 e->vcvttps2uqq(zmmA, anyptr_gpB); 3757 e->vcvttsd2si(gdA, xmmB); 3758 e->vcvttsd2si(gdA, anyptr_gpB); 3759 if (isX64) e->vcvttsd2si(gzA, xmmB); 3760 if (isX64) e->vcvttsd2si(gzA, anyptr_gpB); 3761 e->vcvttsd2usi(gdA, xmmB); 3762 e->vcvttsd2usi(gdA, anyptr_gpB); 3763 if (isX64) e->vcvttsd2usi(gzA, xmmB); 3764 if (isX64) e->vcvttsd2usi(gzA, anyptr_gpB); 3765 e->vcvttss2si(gdA, xmmB); 3766 e->vcvttss2si(gdA, anyptr_gpB); 3767 if (isX64) e->vcvttss2si(gzA, xmmB); 3768 if (isX64) e->vcvttss2si(gzA, anyptr_gpB); 3769 e->vcvttss2usi(gdA, xmmB); 3770 e->vcvttss2usi(gdA, anyptr_gpB); 3771 if (isX64) e->vcvttss2usi(gzA, xmmB); 3772 if (isX64) e->vcvttss2usi(gzA, anyptr_gpB); 3773 e->vcvtudq2pd(xmmA, xmmB); 3774 e->vcvtudq2pd(xmmA, anyptr_gpB); 3775 e->vcvtudq2pd(ymmA, xmmB); 3776 e->vcvtudq2pd(ymmA, anyptr_gpB); 3777 e->vcvtudq2pd(zmmA, ymmB); 3778 e->vcvtudq2pd(zmmA, anyptr_gpB); 3779 e->vcvtudq2ps(xmmA, xmmB); 3780 e->vcvtudq2ps(xmmA, anyptr_gpB); 3781 e->vcvtudq2ps(ymmA, ymmB); 3782 e->vcvtudq2ps(ymmA, anyptr_gpB); 3783 e->vcvtudq2ps(zmmA, zmmB); 3784 e->vcvtudq2ps(zmmA, anyptr_gpB); 3785 e->vcvtuqq2pd(xmmA, xmmB); 3786 e->vcvtuqq2pd(xmmA, anyptr_gpB); 3787 e->vcvtuqq2pd(ymmA, ymmB); 3788 e->vcvtuqq2pd(ymmA, anyptr_gpB); 3789 e->vcvtuqq2pd(zmmA, zmmB); 3790 e->vcvtuqq2pd(zmmA, anyptr_gpB); 3791 e->vcvtuqq2ps(xmmA, xmmB); 3792 e->vcvtuqq2ps(xmmA, anyptr_gpB); 3793 e->vcvtuqq2ps(xmmA, ymmB); 3794 e->vcvtuqq2ps(xmmA, anyptr_gpB); 3795 e->vcvtuqq2ps(ymmA, zmmB); 3796 e->vcvtuqq2ps(ymmA, anyptr_gpB); 3797 e->vcvtusi2sd(xmmA, xmmB, gdC); 3798 e->vcvtusi2sd(xmmA, xmmB, dword_ptr(gzC)); 3799 if (isX64) e->vcvtusi2sd(xmmA, xmmB, gzC); 3800 if (isX64) e->vcvtusi2sd(xmmA, xmmB, qword_ptr(gzC)); 3801 e->vcvtusi2ss(xmmA, xmmB, gdC); 3802 e->vcvtusi2ss(xmmA, xmmB, dword_ptr(gzC)); 3803 if (isX64) e->vcvtusi2ss(xmmA, xmmB, gzC); 3804 if (isX64) e->vcvtusi2ss(xmmA, xmmB, qword_ptr(gzC)); 3805 e->vdbpsadbw(xmmA, xmmB, xmmC, 0); 3806 e->vdbpsadbw(xmmA, xmmB, anyptr_gpC, 0); 3807 e->vdbpsadbw(ymmA, ymmB, ymmC, 0); 3808 e->vdbpsadbw(ymmA, ymmB, anyptr_gpC, 0); 3809 e->vdbpsadbw(zmmA, zmmB, zmmC, 0); 3810 e->vdbpsadbw(zmmA, zmmB, anyptr_gpC, 0); 3811 e->vdivpd(xmmA, xmmB, xmmC); 3812 e->vdivpd(xmmA, xmmB, anyptr_gpC); 3813 e->vdivpd(ymmA, ymmB, ymmC); 3814 e->vdivpd(ymmA, ymmB, anyptr_gpC); 3815 e->vdivpd(zmmA, zmmB, zmmC); 3816 e->vdivpd(zmmA, zmmB, anyptr_gpC); 3817 e->vdivps(xmmA, xmmB, xmmC); 3818 e->vdivps(xmmA, xmmB, anyptr_gpC); 3819 e->vdivps(ymmA, ymmB, ymmC); 3820 e->vdivps(ymmA, ymmB, anyptr_gpC); 3821 e->vdivps(zmmA, zmmB, zmmC); 3822 e->vdivps(zmmA, zmmB, anyptr_gpC); 3823 e->vdivsd(xmmA, xmmB, xmmC); 3824 e->vdivsd(xmmA, xmmB, anyptr_gpC); 3825 e->vdivss(xmmA, xmmB, xmmC); 3826 e->vdivss(xmmA, xmmB, anyptr_gpC); 3827 e->vexp2pd(zmmA, zmmB); 3828 e->vexp2pd(zmmA, anyptr_gpB); 3829 e->vexp2ps(zmmA, zmmB); 3830 e->vexp2ps(zmmA, anyptr_gpB); 3831 e->vexpandpd(xmmA, xmmB); 3832 e->vexpandpd(xmmA, anyptr_gpB); 3833 e->vexpandpd(ymmA, ymmB); 3834 e->vexpandpd(ymmA, anyptr_gpB); 3835 e->vexpandpd(zmmA, zmmB); 3836 e->vexpandpd(zmmA, anyptr_gpB); 3837 e->vexpandps(xmmA, xmmB); 3838 e->vexpandps(xmmA, anyptr_gpB); 3839 e->vexpandps(ymmA, ymmB); 3840 e->vexpandps(ymmA, anyptr_gpB); 3841 e->vexpandps(zmmA, zmmB); 3842 e->vexpandps(zmmA, anyptr_gpB); 3843 e->vextractf32x4(xmmA, ymmB, 0); 3844 e->vextractf32x4(anyptr_gpA, ymmB, 0); 3845 e->vextractf32x4(xmmA, zmmB, 0); 3846 e->vextractf32x4(anyptr_gpA, zmmB, 0); 3847 e->vextractf32x8(ymmA, zmmB, 0); 3848 e->vextractf32x8(anyptr_gpA, zmmB, 0); 3849 e->vextractf64x2(xmmA, ymmB, 0); 3850 e->vextractf64x2(anyptr_gpA, ymmB, 0); 3851 e->vextractf64x2(xmmA, zmmB, 0); 3852 e->vextractf64x2(anyptr_gpA, zmmB, 0); 3853 e->vextractf64x4(ymmA, zmmB, 0); 3854 e->vextractf64x4(anyptr_gpA, zmmB, 0); 3855 e->vextracti32x4(xmmA, ymmB, 0); 3856 e->vextracti32x4(anyptr_gpA, ymmB, 0); 3857 e->vextracti32x4(xmmA, zmmB, 0); 3858 e->vextracti32x4(anyptr_gpA, zmmB, 0); 3859 e->vextracti32x8(ymmA, zmmB, 0); 3860 e->vextracti32x8(anyptr_gpA, zmmB, 0); 3861 e->vextracti64x2(xmmA, ymmB, 0); 3862 e->vextracti64x2(anyptr_gpA, ymmB, 0); 3863 e->vextracti64x2(xmmA, zmmB, 0); 3864 e->vextracti64x2(anyptr_gpA, zmmB, 0); 3865 e->vextracti64x4(ymmA, zmmB, 0); 3866 e->vextracti64x4(anyptr_gpA, zmmB, 0); 3867 e->vextractps(gdA, xmmB, 0); 3868 e->vextractps(gzA, xmmB, 0); 3869 e->vextractps(anyptr_gpA, xmmB, 0); 3870 e->vfixupimmpd(xmmA, xmmB, xmmC, 0); 3871 e->vfixupimmpd(xmmA, xmmB, anyptr_gpC, 0); 3872 e->vfixupimmpd(ymmA, ymmB, ymmC, 0); 3873 e->vfixupimmpd(ymmA, ymmB, anyptr_gpC, 0); 3874 e->vfixupimmpd(zmmA, zmmB, zmmC, 0); 3875 e->vfixupimmpd(zmmA, zmmB, anyptr_gpC, 0); 3876 e->vfixupimmps(xmmA, xmmB, xmmC, 0); 3877 e->vfixupimmps(xmmA, xmmB, anyptr_gpC, 0); 3878 e->vfixupimmps(ymmA, ymmB, ymmC, 0); 3879 e->vfixupimmps(ymmA, ymmB, anyptr_gpC, 0); 3880 e->vfixupimmps(zmmA, zmmB, zmmC, 0); 3881 e->vfixupimmps(zmmA, zmmB, anyptr_gpC, 0); 3882 e->vfixupimmsd(xmmA, xmmB, xmmC, 0); 3883 e->vfixupimmsd(xmmA, xmmB, anyptr_gpC, 0); 3884 e->vfixupimmss(xmmA, xmmB, xmmC, 0); 3885 e->vfixupimmss(xmmA, xmmB, anyptr_gpC, 0); 3886 e->vfmadd132pd(xmmA, xmmB, xmmC); 3887 e->vfmadd132pd(xmmA, xmmB, anyptr_gpC); 3888 e->vfmadd132pd(ymmA, ymmB, ymmC); 3889 e->vfmadd132pd(ymmA, ymmB, anyptr_gpC); 3890 e->vfmadd132pd(zmmA, zmmB, zmmC); 3891 e->vfmadd132pd(zmmA, zmmB, anyptr_gpC); 3892 e->vfmadd132ps(xmmA, xmmB, xmmC); 3893 e->vfmadd132ps(xmmA, xmmB, anyptr_gpC); 3894 e->vfmadd132ps(ymmA, ymmB, ymmC); 3895 e->vfmadd132ps(ymmA, ymmB, anyptr_gpC); 3896 e->vfmadd132ps(zmmA, zmmB, zmmC); 3897 e->vfmadd132ps(zmmA, zmmB, anyptr_gpC); 3898 e->vfmadd132sd(xmmA, xmmB, xmmC); 3899 e->vfmadd132sd(xmmA, xmmB, anyptr_gpC); 3900 e->vfmadd132ss(xmmA, xmmB, xmmC); 3901 e->vfmadd132ss(xmmA, xmmB, anyptr_gpC); 3902 e->vfmadd213pd(xmmA, xmmB, xmmC); 3903 e->vfmadd213pd(xmmA, xmmB, anyptr_gpC); 3904 e->vfmadd213pd(ymmA, ymmB, ymmC); 3905 e->vfmadd213pd(ymmA, ymmB, anyptr_gpC); 3906 e->vfmadd213pd(zmmA, zmmB, zmmC); 3907 e->vfmadd213pd(zmmA, zmmB, anyptr_gpC); 3908 e->vfmadd213ps(xmmA, xmmB, xmmC); 3909 e->vfmadd213ps(xmmA, xmmB, anyptr_gpC); 3910 e->vfmadd213ps(ymmA, ymmB, ymmC); 3911 e->vfmadd213ps(ymmA, ymmB, anyptr_gpC); 3912 e->vfmadd213ps(zmmA, zmmB, zmmC); 3913 e->vfmadd213ps(zmmA, zmmB, anyptr_gpC); 3914 e->vfmadd213sd(xmmA, xmmB, xmmC); 3915 e->vfmadd213sd(xmmA, xmmB, anyptr_gpC); 3916 e->vfmadd213ss(xmmA, xmmB, xmmC); 3917 e->vfmadd213ss(xmmA, xmmB, anyptr_gpC); 3918 e->vfmadd231pd(xmmA, xmmB, xmmC); 3919 e->vfmadd231pd(xmmA, xmmB, anyptr_gpC); 3920 e->vfmadd231pd(ymmA, ymmB, ymmC); 3921 e->vfmadd231pd(ymmA, ymmB, anyptr_gpC); 3922 e->vfmadd231pd(zmmA, zmmB, zmmC); 3923 e->vfmadd231pd(zmmA, zmmB, anyptr_gpC); 3924 e->vfmadd231ps(xmmA, xmmB, xmmC); 3925 e->vfmadd231ps(xmmA, xmmB, anyptr_gpC); 3926 e->vfmadd231ps(ymmA, ymmB, ymmC); 3927 e->vfmadd231ps(ymmA, ymmB, anyptr_gpC); 3928 e->vfmadd231ps(zmmA, zmmB, zmmC); 3929 e->vfmadd231ps(zmmA, zmmB, anyptr_gpC); 3930 e->vfmadd231sd(xmmA, xmmB, xmmC); 3931 e->vfmadd231sd(xmmA, xmmB, anyptr_gpC); 3932 e->vfmadd231ss(xmmA, xmmB, xmmC); 3933 e->vfmadd231ss(xmmA, xmmB, anyptr_gpC); 3934 e->vfmaddsub132pd(xmmA, xmmB, xmmC); 3935 e->vfmaddsub132pd(xmmA, xmmB, anyptr_gpC); 3936 e->vfmaddsub132pd(ymmA, ymmB, ymmC); 3937 e->vfmaddsub132pd(ymmA, ymmB, anyptr_gpC); 3938 e->vfmaddsub132pd(zmmA, zmmB, zmmC); 3939 e->vfmaddsub132pd(zmmA, zmmB, anyptr_gpC); 3940 e->vfmaddsub132ps(xmmA, xmmB, xmmC); 3941 e->vfmaddsub132ps(xmmA, xmmB, anyptr_gpC); 3942 e->vfmaddsub132ps(ymmA, ymmB, ymmC); 3943 e->vfmaddsub132ps(ymmA, ymmB, anyptr_gpC); 3944 e->vfmaddsub132ps(zmmA, zmmB, zmmC); 3945 e->vfmaddsub132ps(zmmA, zmmB, anyptr_gpC); 3946 e->vfmaddsub213pd(xmmA, xmmB, xmmC); 3947 e->vfmaddsub213pd(xmmA, xmmB, anyptr_gpC); 3948 e->vfmaddsub213pd(ymmA, ymmB, ymmC); 3949 e->vfmaddsub213pd(ymmA, ymmB, anyptr_gpC); 3950 e->vfmaddsub213pd(zmmA, zmmB, zmmC); 3951 e->vfmaddsub213pd(zmmA, zmmB, anyptr_gpC); 3952 e->vfmaddsub213ps(xmmA, xmmB, xmmC); 3953 e->vfmaddsub213ps(xmmA, xmmB, anyptr_gpC); 3954 e->vfmaddsub213ps(ymmA, ymmB, ymmC); 3955 e->vfmaddsub213ps(ymmA, ymmB, anyptr_gpC); 3956 e->vfmaddsub213ps(zmmA, zmmB, zmmC); 3957 e->vfmaddsub213ps(zmmA, zmmB, anyptr_gpC); 3958 e->vfmaddsub231pd(xmmA, xmmB, xmmC); 3959 e->vfmaddsub231pd(xmmA, xmmB, anyptr_gpC); 3960 e->vfmaddsub231pd(ymmA, ymmB, ymmC); 3961 e->vfmaddsub231pd(ymmA, ymmB, anyptr_gpC); 3962 e->vfmaddsub231pd(zmmA, zmmB, zmmC); 3963 e->vfmaddsub231pd(zmmA, zmmB, anyptr_gpC); 3964 e->vfmaddsub231ps(xmmA, xmmB, xmmC); 3965 e->vfmaddsub231ps(xmmA, xmmB, anyptr_gpC); 3966 e->vfmaddsub231ps(ymmA, ymmB, ymmC); 3967 e->vfmaddsub231ps(ymmA, ymmB, anyptr_gpC); 3968 e->vfmaddsub231ps(zmmA, zmmB, zmmC); 3969 e->vfmaddsub231ps(zmmA, zmmB, anyptr_gpC); 3970 e->vfmsub132pd(xmmA, xmmB, xmmC); 3971 e->vfmsub132pd(xmmA, xmmB, anyptr_gpC); 3972 e->vfmsub132pd(ymmA, ymmB, ymmC); 3973 e->vfmsub132pd(ymmA, ymmB, anyptr_gpC); 3974 e->vfmsub132pd(zmmA, zmmB, zmmC); 3975 e->vfmsub132pd(zmmA, zmmB, anyptr_gpC); 3976 e->vfmsub132ps(xmmA, xmmB, xmmC); 3977 e->vfmsub132ps(xmmA, xmmB, anyptr_gpC); 3978 e->vfmsub132ps(ymmA, ymmB, ymmC); 3979 e->vfmsub132ps(ymmA, ymmB, anyptr_gpC); 3980 e->vfmsub132ps(zmmA, zmmB, zmmC); 3981 e->vfmsub132ps(zmmA, zmmB, anyptr_gpC); 3982 e->vfmsub132sd(xmmA, xmmB, xmmC); 3983 e->vfmsub132sd(xmmA, xmmB, anyptr_gpC); 3984 e->vfmsub132ss(xmmA, xmmB, xmmC); 3985 e->vfmsub132ss(xmmA, xmmB, anyptr_gpC); 3986 e->vfmsub213pd(xmmA, xmmB, xmmC); 3987 e->vfmsub213pd(xmmA, xmmB, anyptr_gpC); 3988 e->vfmsub213pd(ymmA, ymmB, ymmC); 3989 e->vfmsub213pd(ymmA, ymmB, anyptr_gpC); 3990 e->vfmsub213pd(zmmA, zmmB, zmmC); 3991 e->vfmsub213pd(zmmA, zmmB, anyptr_gpC); 3992 e->vfmsub213ps(xmmA, xmmB, xmmC); 3993 e->vfmsub213ps(xmmA, xmmB, anyptr_gpC); 3994 e->vfmsub213ps(ymmA, ymmB, ymmC); 3995 e->vfmsub213ps(ymmA, ymmB, anyptr_gpC); 3996 e->vfmsub213ps(zmmA, zmmB, zmmC); 3997 e->vfmsub213ps(zmmA, zmmB, anyptr_gpC); 3998 e->vfmsub213sd(xmmA, xmmB, xmmC); 3999 e->vfmsub213sd(xmmA, xmmB, anyptr_gpC); 4000 e->vfmsub213ss(xmmA, xmmB, xmmC); 4001 e->vfmsub213ss(xmmA, xmmB, anyptr_gpC); 4002 e->vfmsub231pd(xmmA, xmmB, xmmC); 4003 e->vfmsub231pd(xmmA, xmmB, anyptr_gpC); 4004 e->vfmsub231pd(ymmA, ymmB, ymmC); 4005 e->vfmsub231pd(ymmA, ymmB, anyptr_gpC); 4006 e->vfmsub231pd(zmmA, zmmB, zmmC); 4007 e->vfmsub231pd(zmmA, zmmB, anyptr_gpC); 4008 e->vfmsub231ps(xmmA, xmmB, xmmC); 4009 e->vfmsub231ps(xmmA, xmmB, anyptr_gpC); 4010 e->vfmsub231ps(ymmA, ymmB, ymmC); 4011 e->vfmsub231ps(ymmA, ymmB, anyptr_gpC); 4012 e->vfmsub231ps(zmmA, zmmB, zmmC); 4013 e->vfmsub231ps(zmmA, zmmB, anyptr_gpC); 4014 e->vfmsub231sd(xmmA, xmmB, xmmC); 4015 e->vfmsub231sd(xmmA, xmmB, anyptr_gpC); 4016 e->vfmsub231ss(xmmA, xmmB, xmmC); 4017 e->vfmsub231ss(xmmA, xmmB, anyptr_gpC); 4018 e->vfmsubadd132pd(xmmA, xmmB, xmmC); 4019 e->vfmsubadd132pd(xmmA, xmmB, anyptr_gpC); 4020 e->vfmsubadd132pd(ymmA, ymmB, ymmC); 4021 e->vfmsubadd132pd(ymmA, ymmB, anyptr_gpC); 4022 e->vfmsubadd132pd(zmmA, zmmB, zmmC); 4023 e->vfmsubadd132pd(zmmA, zmmB, anyptr_gpC); 4024 e->vfmsubadd132ps(xmmA, xmmB, xmmC); 4025 e->vfmsubadd132ps(xmmA, xmmB, anyptr_gpC); 4026 e->vfmsubadd132ps(ymmA, ymmB, ymmC); 4027 e->vfmsubadd132ps(ymmA, ymmB, anyptr_gpC); 4028 e->vfmsubadd132ps(zmmA, zmmB, zmmC); 4029 e->vfmsubadd132ps(zmmA, zmmB, anyptr_gpC); 4030 e->vfmsubadd213pd(xmmA, xmmB, xmmC); 4031 e->vfmsubadd213pd(xmmA, xmmB, anyptr_gpC); 4032 e->vfmsubadd213pd(ymmA, ymmB, ymmC); 4033 e->vfmsubadd213pd(ymmA, ymmB, anyptr_gpC); 4034 e->vfmsubadd213pd(zmmA, zmmB, zmmC); 4035 e->vfmsubadd213pd(zmmA, zmmB, anyptr_gpC); 4036 e->vfmsubadd213ps(xmmA, xmmB, xmmC); 4037 e->vfmsubadd213ps(xmmA, xmmB, anyptr_gpC); 4038 e->vfmsubadd213ps(ymmA, ymmB, ymmC); 4039 e->vfmsubadd213ps(ymmA, ymmB, anyptr_gpC); 4040 e->vfmsubadd213ps(zmmA, zmmB, zmmC); 4041 e->vfmsubadd213ps(zmmA, zmmB, anyptr_gpC); 4042 e->vfmsubadd231pd(xmmA, xmmB, xmmC); 4043 e->vfmsubadd231pd(xmmA, xmmB, anyptr_gpC); 4044 e->vfmsubadd231pd(ymmA, ymmB, ymmC); 4045 e->vfmsubadd231pd(ymmA, ymmB, anyptr_gpC); 4046 e->vfmsubadd231pd(zmmA, zmmB, zmmC); 4047 e->vfmsubadd231pd(zmmA, zmmB, anyptr_gpC); 4048 e->vfmsubadd231ps(xmmA, xmmB, xmmC); 4049 e->vfmsubadd231ps(xmmA, xmmB, anyptr_gpC); 4050 e->vfmsubadd231ps(ymmA, ymmB, ymmC); 4051 e->vfmsubadd231ps(ymmA, ymmB, anyptr_gpC); 4052 e->vfmsubadd231ps(zmmA, zmmB, zmmC); 4053 e->vfmsubadd231ps(zmmA, zmmB, anyptr_gpC); 4054 e->vfnmadd132pd(xmmA, xmmB, xmmC); 4055 e->vfnmadd132pd(xmmA, xmmB, anyptr_gpC); 4056 e->vfnmadd132pd(ymmA, ymmB, ymmC); 4057 e->vfnmadd132pd(ymmA, ymmB, anyptr_gpC); 4058 e->vfnmadd132pd(zmmA, zmmB, zmmC); 4059 e->vfnmadd132pd(zmmA, zmmB, anyptr_gpC); 4060 e->vfnmadd132ps(xmmA, xmmB, xmmC); 4061 e->vfnmadd132ps(xmmA, xmmB, anyptr_gpC); 4062 e->vfnmadd132ps(ymmA, ymmB, ymmC); 4063 e->vfnmadd132ps(ymmA, ymmB, anyptr_gpC); 4064 e->vfnmadd132ps(zmmA, zmmB, zmmC); 4065 e->vfnmadd132ps(zmmA, zmmB, anyptr_gpC); 4066 e->vfnmadd132sd(xmmA, xmmB, xmmC); 4067 e->vfnmadd132sd(xmmA, xmmB, anyptr_gpC); 4068 e->vfnmadd132ss(xmmA, xmmB, xmmC); 4069 e->vfnmadd132ss(xmmA, xmmB, anyptr_gpC); 4070 e->vfnmadd213pd(xmmA, xmmB, xmmC); 4071 e->vfnmadd213pd(xmmA, xmmB, anyptr_gpC); 4072 e->vfnmadd213pd(ymmA, ymmB, ymmC); 4073 e->vfnmadd213pd(ymmA, ymmB, anyptr_gpC); 4074 e->vfnmadd213pd(zmmA, zmmB, zmmC); 4075 e->vfnmadd213pd(zmmA, zmmB, anyptr_gpC); 4076 e->vfnmadd213ps(xmmA, xmmB, xmmC); 4077 e->vfnmadd213ps(xmmA, xmmB, anyptr_gpC); 4078 e->vfnmadd213ps(ymmA, ymmB, ymmC); 4079 e->vfnmadd213ps(ymmA, ymmB, anyptr_gpC); 4080 e->vfnmadd213ps(zmmA, zmmB, zmmC); 4081 e->vfnmadd213ps(zmmA, zmmB, anyptr_gpC); 4082 e->vfnmadd213sd(xmmA, xmmB, xmmC); 4083 e->vfnmadd213sd(xmmA, xmmB, anyptr_gpC); 4084 e->vfnmadd213ss(xmmA, xmmB, xmmC); 4085 e->vfnmadd213ss(xmmA, xmmB, anyptr_gpC); 4086 e->vfnmadd231pd(xmmA, xmmB, xmmC); 4087 e->vfnmadd231pd(xmmA, xmmB, anyptr_gpC); 4088 e->vfnmadd231pd(ymmA, ymmB, ymmC); 4089 e->vfnmadd231pd(ymmA, ymmB, anyptr_gpC); 4090 e->vfnmadd231pd(zmmA, zmmB, zmmC); 4091 e->vfnmadd231pd(zmmA, zmmB, anyptr_gpC); 4092 e->vfnmadd231ps(xmmA, xmmB, xmmC); 4093 e->vfnmadd231ps(xmmA, xmmB, anyptr_gpC); 4094 e->vfnmadd231ps(ymmA, ymmB, ymmC); 4095 e->vfnmadd231ps(ymmA, ymmB, anyptr_gpC); 4096 e->vfnmadd231ps(zmmA, zmmB, zmmC); 4097 e->vfnmadd231ps(zmmA, zmmB, anyptr_gpC); 4098 e->vfnmadd231sd(xmmA, xmmB, xmmC); 4099 e->vfnmadd231sd(xmmA, xmmB, anyptr_gpC); 4100 e->vfnmadd231ss(xmmA, xmmB, xmmC); 4101 e->vfnmadd231ss(xmmA, xmmB, anyptr_gpC); 4102 e->vfnmsub132pd(xmmA, xmmB, xmmC); 4103 e->vfnmsub132pd(xmmA, xmmB, anyptr_gpC); 4104 e->vfnmsub132pd(ymmA, ymmB, ymmC); 4105 e->vfnmsub132pd(ymmA, ymmB, anyptr_gpC); 4106 e->vfnmsub132pd(zmmA, zmmB, zmmC); 4107 e->vfnmsub132pd(zmmA, zmmB, anyptr_gpC); 4108 e->vfnmsub132ps(xmmA, xmmB, xmmC); 4109 e->vfnmsub132ps(xmmA, xmmB, anyptr_gpC); 4110 e->vfnmsub132ps(ymmA, ymmB, ymmC); 4111 e->vfnmsub132ps(ymmA, ymmB, anyptr_gpC); 4112 e->vfnmsub132ps(zmmA, zmmB, zmmC); 4113 e->vfnmsub132ps(zmmA, zmmB, anyptr_gpC); 4114 e->vfnmsub132sd(xmmA, xmmB, xmmC); 4115 e->vfnmsub132sd(xmmA, xmmB, anyptr_gpC); 4116 e->vfnmsub132ss(xmmA, xmmB, xmmC); 4117 e->vfnmsub132ss(xmmA, xmmB, anyptr_gpC); 4118 e->vfnmsub213pd(xmmA, xmmB, xmmC); 4119 e->vfnmsub213pd(xmmA, xmmB, anyptr_gpC); 4120 e->vfnmsub213pd(ymmA, ymmB, ymmC); 4121 e->vfnmsub213pd(ymmA, ymmB, anyptr_gpC); 4122 e->vfnmsub213pd(zmmA, zmmB, zmmC); 4123 e->vfnmsub213pd(zmmA, zmmB, anyptr_gpC); 4124 e->vfnmsub213ps(xmmA, xmmB, xmmC); 4125 e->vfnmsub213ps(xmmA, xmmB, anyptr_gpC); 4126 e->vfnmsub213ps(ymmA, ymmB, ymmC); 4127 e->vfnmsub213ps(ymmA, ymmB, anyptr_gpC); 4128 e->vfnmsub213ps(zmmA, zmmB, zmmC); 4129 e->vfnmsub213ps(zmmA, zmmB, anyptr_gpC); 4130 e->vfnmsub213sd(xmmA, xmmB, xmmC); 4131 e->vfnmsub213sd(xmmA, xmmB, anyptr_gpC); 4132 e->vfnmsub213ss(xmmA, xmmB, xmmC); 4133 e->vfnmsub213ss(xmmA, xmmB, anyptr_gpC); 4134 e->vfnmsub231pd(xmmA, xmmB, xmmC); 4135 e->vfnmsub231pd(xmmA, xmmB, anyptr_gpC); 4136 e->vfnmsub231pd(ymmA, ymmB, ymmC); 4137 e->vfnmsub231pd(ymmA, ymmB, anyptr_gpC); 4138 e->vfnmsub231pd(zmmA, zmmB, zmmC); 4139 e->vfnmsub231pd(zmmA, zmmB, anyptr_gpC); 4140 e->vfnmsub231ps(xmmA, xmmB, xmmC); 4141 e->vfnmsub231ps(xmmA, xmmB, anyptr_gpC); 4142 e->vfnmsub231ps(ymmA, ymmB, ymmC); 4143 e->vfnmsub231ps(ymmA, ymmB, anyptr_gpC); 4144 e->vfnmsub231ps(zmmA, zmmB, zmmC); 4145 e->vfnmsub231ps(zmmA, zmmB, anyptr_gpC); 4146 e->vfnmsub231sd(xmmA, xmmB, xmmC); 4147 e->vfnmsub231sd(xmmA, xmmB, anyptr_gpC); 4148 e->vfnmsub231ss(xmmA, xmmB, xmmC); 4149 e->vfnmsub231ss(xmmA, xmmB, anyptr_gpC); 4150 e->vfpclasspd(kA, xmmB, 0); 4151 e->vfpclasspd(kA, anyptr_gpB, 0); 4152 e->vfpclasspd(kA, ymmB, 0); 4153 e->vfpclasspd(kA, anyptr_gpB, 0); 4154 e->vfpclasspd(kA, zmmB, 0); 4155 e->vfpclasspd(kA, anyptr_gpB, 0); 4156 e->vfpclassps(kA, xmmB, 0); 4157 e->vfpclassps(kA, anyptr_gpB, 0); 4158 e->vfpclassps(kA, ymmB, 0); 4159 e->vfpclassps(kA, anyptr_gpB, 0); 4160 e->vfpclassps(kA, zmmB, 0); 4161 e->vfpclassps(kA, anyptr_gpB, 0); 4162 e->vfpclasssd(kA, xmmB, 0); 4163 e->vfpclasssd(kA, anyptr_gpB, 0); 4164 e->vfpclassss(kA, xmmB, 0); 4165 e->vfpclassss(kA, anyptr_gpB, 0); 4166 e->vgatherdpd(xmmA, vx_ptr); 4167 e->vgatherdpd(ymmA, vy_ptr); 4168 e->vgatherdpd(zmmA, vz_ptr); 4169 e->vgatherdps(xmmA, vx_ptr); 4170 e->vgatherdps(ymmA, vy_ptr); 4171 e->vgatherdps(zmmA, vz_ptr); 4172 e->vgatherpf0dpd(vy_ptr); 4173 e->vgatherpf0dps(vz_ptr); 4174 e->vgatherpf0qpd(vz_ptr); 4175 e->vgatherpf0qps(vz_ptr); 4176 e->vgatherpf1dpd(vy_ptr); 4177 e->vgatherpf1dps(vz_ptr); 4178 e->vgatherpf1qpd(vz_ptr); 4179 e->vgatherpf1qps(vz_ptr); 4180 e->vgatherqpd(xmmA, vx_ptr); 4181 e->vgatherqpd(ymmA, vy_ptr); 4182 e->vgatherqpd(zmmA, vz_ptr); 4183 e->vgatherqps(xmmA, vx_ptr); 4184 e->vgatherqps(ymmA, vy_ptr); 4185 e->vgatherqps(zmmA, vz_ptr); 4186 e->vgetexppd(xmmA, xmmB); 4187 e->vgetexppd(xmmA, anyptr_gpB); 4188 e->vgetexppd(ymmA, ymmB); 4189 e->vgetexppd(ymmA, anyptr_gpB); 4190 e->vgetexppd(zmmA, zmmB); 4191 e->vgetexppd(zmmA, anyptr_gpB); 4192 e->vgetexpps(xmmA, xmmB); 4193 e->vgetexpps(xmmA, anyptr_gpB); 4194 e->vgetexpps(ymmA, ymmB); 4195 e->vgetexpps(ymmA, anyptr_gpB); 4196 e->vgetexpps(zmmA, zmmB); 4197 e->vgetexpps(zmmA, anyptr_gpB); 4198 e->vgetexpsd(xmmA, xmmB, xmmC); 4199 e->vgetexpsd(xmmA, xmmB, anyptr_gpB); 4200 e->vgetexpss(xmmA, xmmB, xmmC); 4201 e->vgetexpss(xmmA, xmmB, anyptr_gpB); 4202 e->vgetmantpd(xmmA, xmmB, 0); 4203 e->vgetmantpd(xmmA, anyptr_gpB, 0); 4204 e->vgetmantpd(ymmA, ymmB, 0); 4205 e->vgetmantpd(ymmA, anyptr_gpB, 0); 4206 e->vgetmantpd(zmmA, zmmB, 0); 4207 e->vgetmantpd(zmmA, anyptr_gpB, 0); 4208 e->vgetmantps(xmmA, xmmB, 0); 4209 e->vgetmantps(xmmA, anyptr_gpB, 0); 4210 e->vgetmantps(ymmA, ymmB, 0); 4211 e->vgetmantps(ymmA, anyptr_gpB, 0); 4212 e->vgetmantps(zmmA, zmmB, 0); 4213 e->vgetmantps(zmmA, anyptr_gpB, 0); 4214 e->vgetmantsd(xmmA, xmmB, xmmC, 0); 4215 e->vgetmantsd(xmmA, xmmB, anyptr_gpB, 0); 4216 e->vgetmantss(xmmA, xmmB, xmmC, 0); 4217 e->vgetmantss(xmmA, xmmB, anyptr_gpB, 0); 4218 e->vinsertf32x4(ymmA, ymmB, xmmC, 0); 4219 e->vinsertf32x4(ymmA, ymmB, anyptr_gpC, 0); 4220 e->vinsertf32x4(zmmA, zmmB, xmmC, 0); 4221 e->vinsertf32x4(zmmA, zmmB, anyptr_gpC, 0); 4222 e->vinsertf32x8(zmmA, zmmB, ymmC, 0); 4223 e->vinsertf32x8(zmmA, zmmB, anyptr_gpC, 0); 4224 e->vinsertf64x2(ymmA, ymmB, xmmC, 0); 4225 e->vinsertf64x2(ymmA, ymmB, anyptr_gpC, 0); 4226 e->vinsertf64x2(zmmA, zmmB, xmmC, 0); 4227 e->vinsertf64x2(zmmA, zmmB, anyptr_gpC, 0); 4228 e->vinsertf64x4(zmmA, zmmB, ymmC, 0); 4229 e->vinsertf64x4(zmmA, zmmB, anyptr_gpC, 0); 4230 e->vinserti32x4(ymmA, ymmB, xmmC, 0); 4231 e->vinserti32x4(ymmA, ymmB, anyptr_gpC, 0); 4232 e->vinserti32x4(zmmA, zmmB, xmmC, 0); 4233 e->vinserti32x4(zmmA, zmmB, anyptr_gpC, 0); 4234 e->vinserti32x8(zmmA, zmmB, ymmC, 0); 4235 e->vinserti32x8(zmmA, zmmB, anyptr_gpC, 0); 4236 e->vinserti64x2(ymmA, ymmB, xmmC, 0); 4237 e->vinserti64x2(ymmA, ymmB, anyptr_gpC, 0); 4238 e->vinserti64x2(zmmA, zmmB, xmmC, 0); 4239 e->vinserti64x2(zmmA, zmmB, anyptr_gpC, 0); 4240 e->vinserti64x4(zmmA, zmmB, ymmC, 0); 4241 e->vinserti64x4(zmmA, zmmB, anyptr_gpC, 0); 4242 e->vinsertps(xmmA, xmmB, xmmC, 0); 4243 e->vinsertps(xmmA, xmmB, anyptr_gpC, 0); 4244 e->vmaxpd(xmmA, xmmB, xmmC); 4245 e->vmaxpd(xmmA, xmmB, anyptr_gpC); 4246 e->vmaxpd(ymmA, ymmB, ymmC); 4247 e->vmaxpd(ymmA, ymmB, anyptr_gpC); 4248 e->vmaxpd(zmmA, zmmB, zmmC); 4249 e->vmaxpd(zmmA, zmmB, anyptr_gpC); 4250 e->vmaxps(xmmA, xmmB, xmmC); 4251 e->vmaxps(xmmA, xmmB, anyptr_gpC); 4252 e->vmaxps(ymmA, ymmB, ymmC); 4253 e->vmaxps(ymmA, ymmB, anyptr_gpC); 4254 e->vmaxps(zmmA, zmmB, zmmC); 4255 e->vmaxps(zmmA, zmmB, anyptr_gpC); 4256 e->vmaxsd(xmmA, xmmB, xmmC); 4257 e->vmaxsd(xmmA, xmmB, anyptr_gpC); 4258 e->vmaxss(xmmA, xmmB, xmmC); 4259 e->vmaxss(xmmA, xmmB, anyptr_gpC); 4260 e->vminpd(xmmA, xmmB, xmmC); 4261 e->vminpd(xmmA, xmmB, anyptr_gpC); 4262 e->vminpd(ymmA, ymmB, ymmC); 4263 e->vminpd(ymmA, ymmB, anyptr_gpC); 4264 e->vminpd(zmmA, zmmB, zmmC); 4265 e->vminpd(zmmA, zmmB, anyptr_gpC); 4266 e->vminps(xmmA, xmmB, xmmC); 4267 e->vminps(xmmA, xmmB, anyptr_gpC); 4268 e->vminps(ymmA, ymmB, ymmC); 4269 e->vminps(ymmA, ymmB, anyptr_gpC); 4270 e->vminps(zmmA, zmmB, zmmC); 4271 e->vminps(zmmA, zmmB, anyptr_gpC); 4272 e->vminsd(xmmA, xmmB, xmmC); 4273 e->vminsd(xmmA, xmmB, anyptr_gpC); 4274 e->vminss(xmmA, xmmB, xmmC); 4275 e->vminss(xmmA, xmmB, anyptr_gpC); 4276 e->vmovapd(xmmA, xmmB); 4277 e->vmovapd(xmmA, anyptr_gpB); 4278 e->vmovapd(xmmA, xmmB); 4279 e->vmovapd(anyptr_gpA, xmmB); 4280 e->vmovapd(ymmA, ymmB); 4281 e->vmovapd(ymmA, anyptr_gpB); 4282 e->vmovapd(ymmA, ymmB); 4283 e->vmovapd(anyptr_gpA, ymmB); 4284 e->vmovapd(zmmA, zmmB); 4285 e->vmovapd(zmmA, anyptr_gpB); 4286 e->vmovapd(zmmA, zmmB); 4287 e->vmovapd(anyptr_gpA, zmmB); 4288 e->vmovaps(xmmA, xmmB); 4289 e->vmovaps(xmmA, anyptr_gpB); 4290 e->vmovaps(xmmA, xmmB); 4291 e->vmovaps(anyptr_gpA, xmmB); 4292 e->vmovaps(ymmA, ymmB); 4293 e->vmovaps(ymmA, anyptr_gpB); 4294 e->vmovaps(ymmA, ymmB); 4295 e->vmovaps(anyptr_gpA, ymmB); 4296 e->vmovaps(zmmA, zmmB); 4297 e->vmovaps(zmmA, anyptr_gpB); 4298 e->vmovaps(zmmA, zmmB); 4299 e->vmovaps(anyptr_gpA, zmmB); 4300 e->vmovd(gdA, xmmB); 4301 e->vmovd(gzA, xmmB); 4302 e->vmovd(anyptr_gpA, xmmB); 4303 e->vmovd(xmmA, gdB); 4304 e->vmovd(xmmA, gzB); 4305 e->vmovd(xmmA, anyptr_gpB); 4306 e->vmovddup(xmmA, xmmB); 4307 e->vmovddup(xmmA, anyptr_gpB); 4308 e->vmovddup(ymmA, ymmB); 4309 e->vmovddup(ymmA, anyptr_gpB); 4310 e->vmovddup(zmmA, zmmB); 4311 e->vmovddup(zmmA, anyptr_gpB); 4312 e->vmovdqa32(xmmA, xmmB); 4313 e->vmovdqa32(xmmA, anyptr_gpB); 4314 e->vmovdqa32(xmmA, xmmB); 4315 e->vmovdqa32(anyptr_gpA, xmmB); 4316 e->vmovdqa32(ymmA, ymmB); 4317 e->vmovdqa32(ymmA, anyptr_gpB); 4318 e->vmovdqa32(ymmA, ymmB); 4319 e->vmovdqa32(anyptr_gpA, ymmB); 4320 e->vmovdqa32(zmmA, zmmB); 4321 e->vmovdqa32(zmmA, anyptr_gpB); 4322 e->vmovdqa32(zmmA, zmmB); 4323 e->vmovdqa32(anyptr_gpA, zmmB); 4324 e->vmovdqa64(xmmA, xmmB); 4325 e->vmovdqa64(xmmA, anyptr_gpB); 4326 e->vmovdqa64(xmmA, xmmB); 4327 e->vmovdqa64(anyptr_gpA, xmmB); 4328 e->vmovdqa64(ymmA, ymmB); 4329 e->vmovdqa64(ymmA, anyptr_gpB); 4330 e->vmovdqa64(ymmA, ymmB); 4331 e->vmovdqa64(anyptr_gpA, ymmB); 4332 e->vmovdqa64(zmmA, zmmB); 4333 e->vmovdqa64(zmmA, anyptr_gpB); 4334 e->vmovdqa64(zmmA, zmmB); 4335 e->vmovdqa64(anyptr_gpA, zmmB); 4336 e->vmovdqu16(xmmA, xmmB); 4337 e->vmovdqu16(xmmA, anyptr_gpB); 4338 e->vmovdqu16(xmmA, xmmB); 4339 e->vmovdqu16(anyptr_gpA, xmmB); 4340 e->vmovdqu16(ymmA, ymmB); 4341 e->vmovdqu16(ymmA, anyptr_gpB); 4342 e->vmovdqu16(ymmA, ymmB); 4343 e->vmovdqu16(anyptr_gpA, ymmB); 4344 e->vmovdqu16(zmmA, zmmB); 4345 e->vmovdqu16(zmmA, anyptr_gpB); 4346 e->vmovdqu16(zmmA, zmmB); 4347 e->vmovdqu16(anyptr_gpA, zmmB); 4348 e->vmovdqu32(xmmA, xmmB); 4349 e->vmovdqu32(xmmA, anyptr_gpB); 4350 e->vmovdqu32(xmmA, xmmB); 4351 e->vmovdqu32(anyptr_gpA, xmmB); 4352 e->vmovdqu32(ymmA, ymmB); 4353 e->vmovdqu32(ymmA, anyptr_gpB); 4354 e->vmovdqu32(ymmA, ymmB); 4355 e->vmovdqu32(anyptr_gpA, ymmB); 4356 e->vmovdqu32(zmmA, zmmB); 4357 e->vmovdqu32(zmmA, anyptr_gpB); 4358 e->vmovdqu32(zmmA, zmmB); 4359 e->vmovdqu32(anyptr_gpA, zmmB); 4360 e->vmovdqu64(xmmA, xmmB); 4361 e->vmovdqu64(xmmA, anyptr_gpB); 4362 e->vmovdqu64(xmmA, xmmB); 4363 e->vmovdqu64(anyptr_gpA, xmmB); 4364 e->vmovdqu64(ymmA, ymmB); 4365 e->vmovdqu64(ymmA, anyptr_gpB); 4366 e->vmovdqu64(ymmA, ymmB); 4367 e->vmovdqu64(anyptr_gpA, ymmB); 4368 e->vmovdqu64(zmmA, zmmB); 4369 e->vmovdqu64(zmmA, anyptr_gpB); 4370 e->vmovdqu64(zmmA, zmmB); 4371 e->vmovdqu64(anyptr_gpA, zmmB); 4372 e->vmovdqu8(xmmA, xmmB); 4373 e->vmovdqu8(xmmA, anyptr_gpB); 4374 e->vmovdqu8(xmmA, xmmB); 4375 e->vmovdqu8(anyptr_gpA, xmmB); 4376 e->vmovdqu8(ymmA, ymmB); 4377 e->vmovdqu8(ymmA, anyptr_gpB); 4378 e->vmovdqu8(ymmA, ymmB); 4379 e->vmovdqu8(anyptr_gpA, ymmB); 4380 e->vmovdqu8(zmmA, zmmB); 4381 e->vmovdqu8(zmmA, anyptr_gpB); 4382 e->vmovdqu8(zmmA, zmmB); 4383 e->vmovdqu8(anyptr_gpA, zmmB); 4384 e->vmovhlps(xmmA, xmmB, xmmC); 4385 e->vmovhpd(anyptr_gpA, xmmB); 4386 e->vmovhpd(xmmA, xmmB, anyptr_gpC); 4387 e->vmovhps(anyptr_gpA, xmmB); 4388 e->vmovhps(xmmA, xmmB, anyptr_gpC); 4389 e->vmovlhps(xmmA, xmmB, xmmC); 4390 e->vmovlpd(anyptr_gpA, xmmB); 4391 e->vmovlpd(xmmA, xmmB, anyptr_gpC); 4392 e->vmovlps(anyptr_gpA, xmmB); 4393 e->vmovlps(xmmA, xmmB, anyptr_gpC); 4394 e->vmovntdq(anyptr_gpA, xmmB); 4395 e->vmovntdq(anyptr_gpA, ymmB); 4396 e->vmovntdq(anyptr_gpA, zmmB); 4397 e->vmovntdqa(xmmA, anyptr_gpB); 4398 e->vmovntdqa(ymmA, anyptr_gpB); 4399 e->vmovntdqa(zmmA, anyptr_gpB); 4400 e->vmovntpd(anyptr_gpA, xmmB); 4401 e->vmovntpd(anyptr_gpA, ymmB); 4402 e->vmovntpd(anyptr_gpA, zmmB); 4403 e->vmovntps(anyptr_gpA, xmmB); 4404 e->vmovntps(anyptr_gpA, ymmB); 4405 e->vmovntps(anyptr_gpA, zmmB); 4406 if (isX64) e->vmovq(gzA, xmmB); 4407 if (isX64) e->vmovq(xmmA, gzB); 4408 e->vmovq(anyptr_gpA, xmmB); 4409 e->vmovq(xmmA, anyptr_gpB); 4410 e->vmovq(xmmA, xmmB); 4411 e->vmovq(xmmA, anyptr_gpB); 4412 e->vmovq(xmmA, xmmB); 4413 e->vmovq(anyptr_gpA, xmmB); 4414 e->vmovsd(anyptr_gpA, xmmB); 4415 e->vmovsd(xmmA, anyptr_gpB); 4416 e->vmovsd(xmmA, xmmB, xmmC); 4417 e->vmovsd(xmmA, xmmB, xmmC); 4418 e->vmovshdup(xmmA, xmmB); 4419 e->vmovshdup(xmmA, anyptr_gpB); 4420 e->vmovshdup(ymmA, ymmB); 4421 e->vmovshdup(ymmA, anyptr_gpB); 4422 e->vmovshdup(zmmA, zmmB); 4423 e->vmovshdup(zmmA, anyptr_gpB); 4424 e->vmovsldup(xmmA, xmmB); 4425 e->vmovsldup(xmmA, anyptr_gpB); 4426 e->vmovsldup(ymmA, ymmB); 4427 e->vmovsldup(ymmA, anyptr_gpB); 4428 e->vmovsldup(zmmA, zmmB); 4429 e->vmovsldup(zmmA, anyptr_gpB); 4430 e->vmovss(anyptr_gpA, xmmB); 4431 e->vmovss(xmmA, anyptr_gpB); 4432 e->vmovss(xmmA, xmmB, xmmC); 4433 e->vmovss(xmmA, xmmB, xmmC); 4434 e->vmovupd(xmmA, xmmB); 4435 e->vmovupd(xmmA, anyptr_gpB); 4436 e->vmovupd(xmmA, xmmB); 4437 e->vmovupd(anyptr_gpA, xmmB); 4438 e->vmovupd(ymmA, ymmB); 4439 e->vmovupd(ymmA, anyptr_gpB); 4440 e->vmovupd(ymmA, ymmB); 4441 e->vmovupd(anyptr_gpA, ymmB); 4442 e->vmovupd(zmmA, zmmB); 4443 e->vmovupd(zmmA, anyptr_gpB); 4444 e->vmovupd(zmmA, zmmB); 4445 e->vmovupd(anyptr_gpA, zmmB); 4446 e->vmovups(xmmA, xmmB); 4447 e->vmovups(xmmA, anyptr_gpB); 4448 e->vmovups(xmmA, xmmB); 4449 e->vmovups(anyptr_gpA, xmmB); 4450 e->vmovups(ymmA, ymmB); 4451 e->vmovups(ymmA, anyptr_gpB); 4452 e->vmovups(ymmA, ymmB); 4453 e->vmovups(anyptr_gpA, ymmB); 4454 e->vmovups(zmmA, zmmB); 4455 e->vmovups(zmmA, anyptr_gpB); 4456 e->vmovups(zmmA, zmmB); 4457 e->vmovups(anyptr_gpA, zmmB); 4458 e->vmulpd(xmmA, xmmB, xmmC); 4459 e->vmulpd(xmmA, xmmB, anyptr_gpC); 4460 e->vmulpd(ymmA, ymmB, ymmC); 4461 e->vmulpd(ymmA, ymmB, anyptr_gpC); 4462 e->vmulpd(zmmA, zmmB, zmmC); 4463 e->vmulpd(zmmA, zmmB, anyptr_gpC); 4464 e->vmulps(xmmA, xmmB, xmmC); 4465 e->vmulps(xmmA, xmmB, anyptr_gpC); 4466 e->vmulps(ymmA, ymmB, ymmC); 4467 e->vmulps(ymmA, ymmB, anyptr_gpC); 4468 e->vmulps(zmmA, zmmB, zmmC); 4469 e->vmulps(zmmA, zmmB, anyptr_gpC); 4470 e->vmulsd(xmmA, xmmB, xmmC); 4471 e->vmulsd(xmmA, xmmB, anyptr_gpC); 4472 e->vmulss(xmmA, xmmB, xmmC); 4473 e->vmulss(xmmA, xmmB, anyptr_gpC); 4474 e->vorpd(xmmA, xmmB, xmmC); 4475 e->vorpd(xmmA, xmmB, anyptr_gpC); 4476 e->vorpd(ymmA, ymmB, ymmC); 4477 e->vorpd(ymmA, ymmB, anyptr_gpC); 4478 e->vorpd(zmmA, zmmB, zmmC); 4479 e->vorpd(zmmA, zmmB, anyptr_gpC); 4480 e->vorps(xmmA, xmmB, xmmC); 4481 e->vorps(xmmA, xmmB, anyptr_gpC); 4482 e->vorps(ymmA, ymmB, ymmC); 4483 e->vorps(ymmA, ymmB, anyptr_gpC); 4484 e->vorps(zmmA, zmmB, zmmC); 4485 e->vorps(zmmA, zmmB, anyptr_gpC); 4486 e->vpabsb(xmmA, xmmB); 4487 e->vpabsb(xmmA, anyptr_gpB); 4488 e->vpabsb(ymmA, ymmB); 4489 e->vpabsb(ymmA, anyptr_gpB); 4490 e->vpabsb(zmmA, zmmB); 4491 e->vpabsb(zmmA, anyptr_gpB); 4492 e->vpabsd(xmmA, xmmB); 4493 e->vpabsd(xmmA, anyptr_gpB); 4494 e->vpabsd(ymmA, ymmB); 4495 e->vpabsd(ymmA, anyptr_gpB); 4496 e->vpabsd(zmmA, zmmB); 4497 e->vpabsd(zmmA, anyptr_gpB); 4498 e->vpabsq(xmmA, xmmB); 4499 e->vpabsq(xmmA, anyptr_gpB); 4500 e->vpabsq(ymmA, ymmB); 4501 e->vpabsq(ymmA, anyptr_gpB); 4502 e->vpabsq(zmmA, zmmB); 4503 e->vpabsq(zmmA, anyptr_gpB); 4504 e->vpabsw(xmmA, xmmB); 4505 e->vpabsw(xmmA, anyptr_gpB); 4506 e->vpabsw(ymmA, ymmB); 4507 e->vpabsw(ymmA, anyptr_gpB); 4508 e->vpabsw(zmmA, zmmB); 4509 e->vpabsw(zmmA, anyptr_gpB); 4510 e->vpackssdw(xmmA, xmmB, xmmC); 4511 e->vpackssdw(xmmA, xmmB, anyptr_gpC); 4512 e->vpackssdw(ymmA, ymmB, ymmC); 4513 e->vpackssdw(ymmA, ymmB, anyptr_gpC); 4514 e->vpackssdw(zmmA, zmmB, zmmC); 4515 e->vpackssdw(zmmA, zmmB, anyptr_gpC); 4516 e->vpacksswb(xmmA, xmmB, xmmC); 4517 e->vpacksswb(xmmA, xmmB, anyptr_gpC); 4518 e->vpacksswb(ymmA, ymmB, ymmC); 4519 e->vpacksswb(ymmA, ymmB, anyptr_gpC); 4520 e->vpacksswb(zmmA, zmmB, zmmC); 4521 e->vpacksswb(zmmA, zmmB, anyptr_gpC); 4522 e->vpackusdw(xmmA, xmmB, xmmC); 4523 e->vpackusdw(xmmA, xmmB, anyptr_gpC); 4524 e->vpackusdw(ymmA, ymmB, ymmC); 4525 e->vpackusdw(ymmA, ymmB, anyptr_gpC); 4526 e->vpackusdw(zmmA, zmmB, zmmC); 4527 e->vpackusdw(zmmA, zmmB, anyptr_gpC); 4528 e->vpackuswb(xmmA, xmmB, xmmC); 4529 e->vpackuswb(xmmA, xmmB, anyptr_gpC); 4530 e->vpackuswb(ymmA, ymmB, ymmC); 4531 e->vpackuswb(ymmA, ymmB, anyptr_gpC); 4532 e->vpackuswb(zmmA, zmmB, zmmC); 4533 e->vpackuswb(zmmA, zmmB, anyptr_gpC); 4534 e->vpaddb(xmmA, xmmB, xmmC); 4535 e->vpaddb(xmmA, xmmB, anyptr_gpC); 4536 e->vpaddb(ymmA, ymmB, ymmC); 4537 e->vpaddb(ymmA, ymmB, anyptr_gpC); 4538 e->vpaddb(zmmA, zmmB, zmmC); 4539 e->vpaddb(zmmA, zmmB, anyptr_gpC); 4540 e->vpaddd(xmmA, xmmB, xmmC); 4541 e->vpaddd(xmmA, xmmB, anyptr_gpC); 4542 e->vpaddd(ymmA, ymmB, ymmC); 4543 e->vpaddd(ymmA, ymmB, anyptr_gpC); 4544 e->vpaddd(zmmA, zmmB, zmmC); 4545 e->vpaddd(zmmA, zmmB, anyptr_gpC); 4546 e->vpaddq(xmmA, xmmB, xmmC); 4547 e->vpaddq(xmmA, xmmB, anyptr_gpC); 4548 e->vpaddq(ymmA, ymmB, ymmC); 4549 e->vpaddq(ymmA, ymmB, anyptr_gpC); 4550 e->vpaddq(zmmA, zmmB, zmmC); 4551 e->vpaddq(zmmA, zmmB, anyptr_gpC); 4552 e->vpaddsb(xmmA, xmmB, xmmC); 4553 e->vpaddsb(xmmA, xmmB, anyptr_gpC); 4554 e->vpaddsb(ymmA, ymmB, ymmC); 4555 e->vpaddsb(ymmA, ymmB, anyptr_gpC); 4556 e->vpaddsb(zmmA, zmmB, zmmC); 4557 e->vpaddsb(zmmA, zmmB, anyptr_gpC); 4558 e->vpaddsw(xmmA, xmmB, xmmC); 4559 e->vpaddsw(xmmA, xmmB, anyptr_gpC); 4560 e->vpaddsw(ymmA, ymmB, ymmC); 4561 e->vpaddsw(ymmA, ymmB, anyptr_gpC); 4562 e->vpaddsw(zmmA, zmmB, zmmC); 4563 e->vpaddsw(zmmA, zmmB, anyptr_gpC); 4564 e->vpaddusb(xmmA, xmmB, xmmC); 4565 e->vpaddusb(xmmA, xmmB, anyptr_gpC); 4566 e->vpaddusb(ymmA, ymmB, ymmC); 4567 e->vpaddusb(ymmA, ymmB, anyptr_gpC); 4568 e->vpaddusb(zmmA, zmmB, zmmC); 4569 e->vpaddusb(zmmA, zmmB, anyptr_gpC); 4570 e->vpaddusw(xmmA, xmmB, xmmC); 4571 e->vpaddusw(xmmA, xmmB, anyptr_gpC); 4572 e->vpaddusw(ymmA, ymmB, ymmC); 4573 e->vpaddusw(ymmA, ymmB, anyptr_gpC); 4574 e->vpaddusw(zmmA, zmmB, zmmC); 4575 e->vpaddusw(zmmA, zmmB, anyptr_gpC); 4576 e->vpaddw(xmmA, xmmB, xmmC); 4577 e->vpaddw(xmmA, xmmB, anyptr_gpC); 4578 e->vpaddw(ymmA, ymmB, ymmC); 4579 e->vpaddw(ymmA, ymmB, anyptr_gpC); 4580 e->vpaddw(zmmA, zmmB, zmmC); 4581 e->vpaddw(zmmA, zmmB, anyptr_gpC); 4582 e->vpalignr(xmmA, xmmB, xmmC, 0); 4583 e->vpalignr(xmmA, xmmB, anyptr_gpC, 0); 4584 e->vpalignr(ymmA, ymmB, ymmC, 0); 4585 e->vpalignr(ymmA, ymmB, anyptr_gpC, 0); 4586 e->vpalignr(zmmA, zmmB, zmmC, 0); 4587 e->vpalignr(zmmA, zmmB, anyptr_gpC, 0); 4588 e->vpandd(xmmA, xmmB, xmmC); 4589 e->vpandd(xmmA, xmmB, anyptr_gpC); 4590 e->vpandd(ymmA, ymmB, ymmC); 4591 e->vpandd(ymmA, ymmB, anyptr_gpC); 4592 e->vpandd(zmmA, zmmB, zmmC); 4593 e->vpandd(zmmA, zmmB, anyptr_gpC); 4594 e->vpandnd(xmmA, xmmB, xmmC); 4595 e->vpandnd(xmmA, xmmB, anyptr_gpC); 4596 e->vpandnd(ymmA, ymmB, ymmC); 4597 e->vpandnd(ymmA, ymmB, anyptr_gpC); 4598 e->vpandnd(zmmA, zmmB, zmmC); 4599 e->vpandnd(zmmA, zmmB, anyptr_gpC); 4600 e->vpandnq(xmmA, xmmB, xmmC); 4601 e->vpandnq(xmmA, xmmB, anyptr_gpC); 4602 e->vpandnq(ymmA, ymmB, ymmC); 4603 e->vpandnq(ymmA, ymmB, anyptr_gpC); 4604 e->vpandnq(zmmA, zmmB, zmmC); 4605 e->vpandnq(zmmA, zmmB, anyptr_gpC); 4606 e->vpandq(xmmA, xmmB, xmmC); 4607 e->vpandq(xmmA, xmmB, anyptr_gpC); 4608 e->vpandq(ymmA, ymmB, ymmC); 4609 e->vpandq(ymmA, ymmB, anyptr_gpC); 4610 e->vpandq(zmmA, zmmB, zmmC); 4611 e->vpandq(zmmA, zmmB, anyptr_gpC); 4612 e->vpavgb(xmmA, xmmB, xmmC); 4613 e->vpavgb(xmmA, xmmB, anyptr_gpC); 4614 e->vpavgb(ymmA, ymmB, ymmC); 4615 e->vpavgb(ymmA, ymmB, anyptr_gpC); 4616 e->vpavgb(zmmA, zmmB, zmmC); 4617 e->vpavgb(zmmA, zmmB, anyptr_gpC); 4618 e->vpavgw(xmmA, xmmB, xmmC); 4619 e->vpavgw(xmmA, xmmB, anyptr_gpC); 4620 e->vpavgw(ymmA, ymmB, ymmC); 4621 e->vpavgw(ymmA, ymmB, anyptr_gpC); 4622 e->vpavgw(zmmA, zmmB, zmmC); 4623 e->vpavgw(zmmA, zmmB, anyptr_gpC); 4624 e->vpbroadcastb(xmmA, gdB); 4625 e->vpbroadcastb(xmmA, gzB); 4626 e->vpbroadcastb(xmmA, xmmB); 4627 e->vpbroadcastb(xmmA, anyptr_gpB); 4628 e->vpbroadcastb(ymmA, gdB); 4629 e->vpbroadcastb(ymmA, gzB); 4630 e->vpbroadcastb(ymmA, xmmB); 4631 e->vpbroadcastb(ymmA, anyptr_gpB); 4632 e->vpbroadcastb(zmmA, gdB); 4633 e->vpbroadcastb(zmmA, gzB); 4634 e->vpbroadcastb(zmmA, xmmB); 4635 e->vpbroadcastb(zmmA, anyptr_gpB); 4636 e->vpbroadcastd(xmmA, gdB); 4637 e->vpbroadcastd(xmmA, gzB); 4638 e->vpbroadcastd(xmmA, xmmB); 4639 e->vpbroadcastd(xmmA, anyptr_gpB); 4640 e->vpbroadcastd(ymmA, gdB); 4641 e->vpbroadcastd(ymmA, gzB); 4642 e->vpbroadcastd(ymmA, xmmB); 4643 e->vpbroadcastd(ymmA, anyptr_gpB); 4644 e->vpbroadcastd(zmmA, gdB); 4645 e->vpbroadcastd(zmmA, gzB); 4646 e->vpbroadcastd(zmmA, xmmB); 4647 e->vpbroadcastd(zmmA, anyptr_gpB); 4648 e->vpbroadcastmb2d(xmmA, kB); 4649 e->vpbroadcastmb2d(ymmA, kB); 4650 e->vpbroadcastmb2d(zmmA, kB); 4651 e->vpbroadcastmb2q(xmmA, kB); 4652 e->vpbroadcastmb2q(ymmA, kB); 4653 e->vpbroadcastmb2q(zmmA, kB); 4654 if (isX64) e->vpbroadcastq(xmmA, gzB); 4655 e->vpbroadcastq(xmmA, xmmB); 4656 e->vpbroadcastq(xmmA, anyptr_gpB); 4657 if (isX64) e->vpbroadcastq(ymmA, gzB); 4658 e->vpbroadcastq(ymmA, xmmB); 4659 e->vpbroadcastq(ymmA, anyptr_gpB); 4660 if (isX64) e->vpbroadcastq(zmmA, gzB); 4661 e->vpbroadcastq(zmmA, xmmB); 4662 e->vpbroadcastq(zmmA, anyptr_gpB); 4663 e->vpbroadcastw(xmmA, gdB); 4664 e->vpbroadcastw(xmmA, gzB); 4665 e->vpbroadcastw(xmmA, xmmB); 4666 e->vpbroadcastw(xmmA, anyptr_gpB); 4667 e->vpbroadcastw(ymmA, gdB); 4668 e->vpbroadcastw(ymmA, gzB); 4669 e->vpbroadcastw(ymmA, xmmB); 4670 e->vpbroadcastw(ymmA, anyptr_gpB); 4671 e->vpbroadcastw(zmmA, gdB); 4672 e->vpbroadcastw(zmmA, gzB); 4673 e->vpbroadcastw(zmmA, xmmB); 4674 e->vpbroadcastw(zmmA, anyptr_gpB); 4675 e->vpcmpb(kA, xmmB, xmmC, 0); 4676 e->vpcmpb(kA, xmmB, anyptr_gpC, 0); 4677 e->vpcmpb(kA, ymmB, ymmC, 0); 4678 e->vpcmpb(kA, ymmB, anyptr_gpC, 0); 4679 e->vpcmpb(kA, zmmB, zmmC, 0); 4680 e->vpcmpb(kA, zmmB, anyptr_gpC, 0); 4681 e->vpcmpd(kA, xmmB, xmmC, 0); 4682 e->vpcmpd(kA, xmmB, anyptr_gpC, 0); 4683 e->vpcmpd(kA, ymmB, ymmC, 0); 4684 e->vpcmpd(kA, ymmB, anyptr_gpC, 0); 4685 e->vpcmpd(kA, zmmB, zmmC, 0); 4686 e->vpcmpd(kA, zmmB, anyptr_gpC, 0); 4687 e->vpcmpeqb(kA, xmmB, xmmC); 4688 e->vpcmpeqb(kA, xmmB, anyptr_gpC); 4689 e->vpcmpeqb(kA, ymmB, ymmC); 4690 e->vpcmpeqb(kA, ymmB, anyptr_gpC); 4691 e->vpcmpeqb(kA, zmmB, zmmC); 4692 e->vpcmpeqb(kA, zmmB, anyptr_gpC); 4693 e->vpcmpeqd(kA, xmmB, xmmC); 4694 e->vpcmpeqd(kA, xmmB, anyptr_gpC); 4695 e->vpcmpeqd(kA, ymmB, ymmC); 4696 e->vpcmpeqd(kA, ymmB, anyptr_gpC); 4697 e->vpcmpeqd(kA, zmmB, zmmC); 4698 e->vpcmpeqd(kA, zmmB, anyptr_gpC); 4699 e->vpcmpeqq(kA, xmmB, xmmC); 4700 e->vpcmpeqq(kA, xmmB, anyptr_gpC); 4701 e->vpcmpeqq(kA, ymmB, ymmC); 4702 e->vpcmpeqq(kA, ymmB, anyptr_gpC); 4703 e->vpcmpeqq(kA, zmmB, zmmC); 4704 e->vpcmpeqq(kA, zmmB, anyptr_gpC); 4705 e->vpcmpeqw(kA, xmmB, xmmC); 4706 e->vpcmpeqw(kA, xmmB, anyptr_gpC); 4707 e->vpcmpeqw(kA, ymmB, ymmC); 4708 e->vpcmpeqw(kA, ymmB, anyptr_gpC); 4709 e->vpcmpeqw(kA, zmmB, zmmC); 4710 e->vpcmpeqw(kA, zmmB, anyptr_gpC); 4711 e->vpcmpgtb(kA, xmmB, xmmC); 4712 e->vpcmpgtb(kA, xmmB, anyptr_gpC); 4713 e->vpcmpgtb(kA, ymmB, ymmC); 4714 e->vpcmpgtb(kA, ymmB, anyptr_gpC); 4715 e->vpcmpgtb(kA, zmmB, zmmC); 4716 e->vpcmpgtb(kA, zmmB, anyptr_gpC); 4717 e->vpcmpgtd(kA, xmmB, xmmC); 4718 e->vpcmpgtd(kA, xmmB, anyptr_gpC); 4719 e->vpcmpgtd(kA, ymmB, ymmC); 4720 e->vpcmpgtd(kA, ymmB, anyptr_gpC); 4721 e->vpcmpgtd(kA, zmmB, zmmC); 4722 e->vpcmpgtd(kA, zmmB, anyptr_gpC); 4723 e->vpcmpgtq(kA, xmmB, xmmC); 4724 e->vpcmpgtq(kA, xmmB, anyptr_gpC); 4725 e->vpcmpgtq(kA, ymmB, ymmC); 4726 e->vpcmpgtq(kA, ymmB, anyptr_gpC); 4727 e->vpcmpgtq(kA, zmmB, zmmC); 4728 e->vpcmpgtq(kA, zmmB, anyptr_gpC); 4729 e->vpcmpgtw(kA, xmmB, xmmC); 4730 e->vpcmpgtw(kA, xmmB, anyptr_gpC); 4731 e->vpcmpgtw(kA, ymmB, ymmC); 4732 e->vpcmpgtw(kA, ymmB, anyptr_gpC); 4733 e->vpcmpgtw(kA, zmmB, zmmC); 4734 e->vpcmpgtw(kA, zmmB, anyptr_gpC); 4735 e->vpcmpq(kA, xmmB, xmmC, 0); 4736 e->vpcmpq(kA, xmmB, anyptr_gpC, 0); 4737 e->vpcmpq(kA, ymmB, ymmC, 0); 4738 e->vpcmpq(kA, ymmB, anyptr_gpC, 0); 4739 e->vpcmpq(kA, zmmB, zmmC, 0); 4740 e->vpcmpq(kA, zmmB, anyptr_gpC, 0); 4741 e->vpcmpub(kA, xmmB, xmmC, 0); 4742 e->vpcmpub(kA, xmmB, anyptr_gpC, 0); 4743 e->vpcmpub(kA, ymmB, ymmC, 0); 4744 e->vpcmpub(kA, ymmB, anyptr_gpC, 0); 4745 e->vpcmpub(kA, zmmB, zmmC, 0); 4746 e->vpcmpub(kA, zmmB, anyptr_gpC, 0); 4747 e->vpcmpud(kA, xmmB, xmmC, 0); 4748 e->vpcmpud(kA, xmmB, anyptr_gpC, 0); 4749 e->vpcmpud(kA, ymmB, ymmC, 0); 4750 e->vpcmpud(kA, ymmB, anyptr_gpC, 0); 4751 e->vpcmpud(kA, zmmB, zmmC, 0); 4752 e->vpcmpud(kA, zmmB, anyptr_gpC, 0); 4753 e->vpcmpuq(kA, xmmB, xmmC, 0); 4754 e->vpcmpuq(kA, xmmB, anyptr_gpC, 0); 4755 e->vpcmpuq(kA, ymmB, ymmC, 0); 4756 e->vpcmpuq(kA, ymmB, anyptr_gpC, 0); 4757 e->vpcmpuq(kA, zmmB, zmmC, 0); 4758 e->vpcmpuq(kA, zmmB, anyptr_gpC, 0); 4759 e->vpcmpuw(kA, xmmB, xmmC, 0); 4760 e->vpcmpuw(kA, xmmB, anyptr_gpC, 0); 4761 e->vpcmpuw(kA, ymmB, ymmC, 0); 4762 e->vpcmpuw(kA, ymmB, anyptr_gpC, 0); 4763 e->vpcmpuw(kA, zmmB, zmmC, 0); 4764 e->vpcmpuw(kA, zmmB, anyptr_gpC, 0); 4765 e->vpcmpw(kA, xmmB, xmmC, 0); 4766 e->vpcmpw(kA, xmmB, anyptr_gpC, 0); 4767 e->vpcmpw(kA, ymmB, ymmC, 0); 4768 e->vpcmpw(kA, ymmB, anyptr_gpC, 0); 4769 e->vpcmpw(kA, zmmB, zmmC, 0); 4770 e->vpcmpw(kA, zmmB, anyptr_gpC, 0); 4771 e->vpcompressd(xmmA, xmmB); 4772 e->vpcompressd(anyptr_gpA, xmmB); 4773 e->vpcompressd(ymmA, ymmB); 4774 e->vpcompressd(anyptr_gpA, ymmB); 4775 e->vpcompressd(zmmA, zmmB); 4776 e->vpcompressd(anyptr_gpA, zmmB); 4777 e->vpcompressq(xmmA, xmmB); 4778 e->vpcompressq(anyptr_gpA, xmmB); 4779 e->vpcompressq(ymmA, ymmB); 4780 e->vpcompressq(anyptr_gpA, ymmB); 4781 e->vpcompressq(zmmA, zmmB); 4782 e->vpcompressq(anyptr_gpA, zmmB); 4783 e->vpconflictd(xmmA, xmmB); 4784 e->vpconflictd(xmmA, anyptr_gpB); 4785 e->vpconflictd(ymmA, ymmB); 4786 e->vpconflictd(ymmA, anyptr_gpB); 4787 e->vpconflictd(zmmA, zmmB); 4788 e->vpconflictd(zmmA, anyptr_gpB); 4789 e->vpconflictq(xmmA, xmmB); 4790 e->vpconflictq(xmmA, anyptr_gpB); 4791 e->vpconflictq(ymmA, ymmB); 4792 e->vpconflictq(ymmA, anyptr_gpB); 4793 e->vpconflictq(zmmA, zmmB); 4794 e->vpconflictq(zmmA, anyptr_gpB); 4795 e->vpermb(xmmA, xmmB, xmmC); 4796 e->vpermb(xmmA, xmmB, anyptr_gpC); 4797 e->vpermb(ymmA, ymmB, ymmC); 4798 e->vpermb(ymmA, ymmB, anyptr_gpC); 4799 e->vpermb(zmmA, zmmB, zmmC); 4800 e->vpermb(zmmA, zmmB, anyptr_gpC); 4801 e->vpermd(ymmA, ymmB, ymmC); 4802 e->vpermd(ymmA, ymmB, anyptr_gpC); 4803 e->vpermd(zmmA, zmmB, zmmC); 4804 e->vpermd(zmmA, zmmB, anyptr_gpC); 4805 e->vpermi2b(xmmA, xmmB, xmmC); 4806 e->vpermi2b(xmmA, xmmB, anyptr_gpC); 4807 e->vpermi2b(ymmA, ymmB, ymmC); 4808 e->vpermi2b(ymmA, ymmB, anyptr_gpC); 4809 e->vpermi2b(zmmA, zmmB, zmmC); 4810 e->vpermi2b(zmmA, zmmB, anyptr_gpC); 4811 e->vpermi2d(xmmA, xmmB, xmmC); 4812 e->vpermi2d(xmmA, xmmB, anyptr_gpC); 4813 e->vpermi2d(ymmA, ymmB, ymmC); 4814 e->vpermi2d(ymmA, ymmB, anyptr_gpC); 4815 e->vpermi2d(zmmA, zmmB, zmmC); 4816 e->vpermi2d(zmmA, zmmB, anyptr_gpC); 4817 e->vpermi2pd(xmmA, xmmB, xmmC); 4818 e->vpermi2pd(xmmA, xmmB, anyptr_gpC); 4819 e->vpermi2pd(ymmA, ymmB, ymmC); 4820 e->vpermi2pd(ymmA, ymmB, anyptr_gpC); 4821 e->vpermi2pd(zmmA, zmmB, zmmC); 4822 e->vpermi2pd(zmmA, zmmB, anyptr_gpC); 4823 e->vpermi2ps(xmmA, xmmB, xmmC); 4824 e->vpermi2ps(xmmA, xmmB, anyptr_gpC); 4825 e->vpermi2ps(ymmA, ymmB, ymmC); 4826 e->vpermi2ps(ymmA, ymmB, anyptr_gpC); 4827 e->vpermi2ps(zmmA, zmmB, zmmC); 4828 e->vpermi2ps(zmmA, zmmB, anyptr_gpC); 4829 e->vpermi2q(xmmA, xmmB, xmmC); 4830 e->vpermi2q(xmmA, xmmB, anyptr_gpC); 4831 e->vpermi2q(ymmA, ymmB, ymmC); 4832 e->vpermi2q(ymmA, ymmB, anyptr_gpC); 4833 e->vpermi2q(zmmA, zmmB, zmmC); 4834 e->vpermi2q(zmmA, zmmB, anyptr_gpC); 4835 e->vpermi2w(xmmA, xmmB, xmmC); 4836 e->vpermi2w(xmmA, xmmB, anyptr_gpC); 4837 e->vpermi2w(ymmA, ymmB, ymmC); 4838 e->vpermi2w(ymmA, ymmB, anyptr_gpC); 4839 e->vpermi2w(zmmA, zmmB, zmmC); 4840 e->vpermi2w(zmmA, zmmB, anyptr_gpC); 4841 e->vpermilpd(xmmA, xmmB, xmmC); 4842 e->vpermilpd(xmmA, xmmB, anyptr_gpC); 4843 e->vpermilpd(ymmA, ymmB, ymmC); 4844 e->vpermilpd(ymmA, ymmB, anyptr_gpC); 4845 e->vpermilpd(zmmA, zmmB, zmmC); 4846 e->vpermilpd(zmmA, zmmB, anyptr_gpC); 4847 e->vpermilpd(xmmA, xmmB, 0); 4848 e->vpermilpd(xmmA, anyptr_gpB, 0); 4849 e->vpermilpd(ymmA, ymmB, 0); 4850 e->vpermilpd(ymmA, anyptr_gpB, 0); 4851 e->vpermilpd(zmmA, zmmB, 0); 4852 e->vpermilpd(zmmA, anyptr_gpB, 0); 4853 e->vpermilps(xmmA, xmmB, xmmC); 4854 e->vpermilps(xmmA, xmmB, anyptr_gpC); 4855 e->vpermilps(ymmA, ymmB, ymmC); 4856 e->vpermilps(ymmA, ymmB, anyptr_gpC); 4857 e->vpermilps(zmmA, zmmB, zmmC); 4858 e->vpermilps(zmmA, zmmB, anyptr_gpC); 4859 e->vpermilps(xmmA, xmmB, 0); 4860 e->vpermilps(xmmA, anyptr_gpB, 0); 4861 e->vpermilps(ymmA, ymmB, 0); 4862 e->vpermilps(ymmA, anyptr_gpB, 0); 4863 e->vpermilps(zmmA, zmmB, 0); 4864 e->vpermilps(zmmA, anyptr_gpB, 0); 4865 e->vpermq(ymmA, ymmB, ymmC); 4866 e->vpermq(ymmA, ymmB, anyptr_gpC); 4867 e->vpermq(zmmA, zmmB, zmmC); 4868 e->vpermq(zmmA, zmmB, anyptr_gpC); 4869 e->vpermq(ymmA, ymmB, 0); 4870 e->vpermq(ymmA, anyptr_gpB, 0); 4871 e->vpermq(zmmA, zmmB, 0); 4872 e->vpermq(zmmA, anyptr_gpB, 0); 4873 e->vpermt2b(xmmA, xmmB, xmmC); 4874 e->vpermt2b(xmmA, xmmB, anyptr_gpC); 4875 e->vpermt2b(ymmA, ymmB, ymmC); 4876 e->vpermt2b(ymmA, ymmB, anyptr_gpC); 4877 e->vpermt2b(zmmA, zmmB, zmmC); 4878 e->vpermt2b(zmmA, zmmB, anyptr_gpC); 4879 e->vpermt2d(xmmA, xmmB, xmmC); 4880 e->vpermt2d(xmmA, xmmB, anyptr_gpC); 4881 e->vpermt2d(ymmA, ymmB, ymmC); 4882 e->vpermt2d(ymmA, ymmB, anyptr_gpC); 4883 e->vpermt2d(zmmA, zmmB, zmmC); 4884 e->vpermt2d(zmmA, zmmB, anyptr_gpC); 4885 e->vpermt2pd(xmmA, xmmB, xmmC); 4886 e->vpermt2pd(xmmA, xmmB, anyptr_gpC); 4887 e->vpermt2pd(ymmA, ymmB, ymmC); 4888 e->vpermt2pd(ymmA, ymmB, anyptr_gpC); 4889 e->vpermt2pd(zmmA, zmmB, zmmC); 4890 e->vpermt2pd(zmmA, zmmB, anyptr_gpC); 4891 e->vpermt2ps(xmmA, xmmB, xmmC); 4892 e->vpermt2ps(xmmA, xmmB, anyptr_gpC); 4893 e->vpermt2ps(ymmA, ymmB, ymmC); 4894 e->vpermt2ps(ymmA, ymmB, anyptr_gpC); 4895 e->vpermt2ps(zmmA, zmmB, zmmC); 4896 e->vpermt2ps(zmmA, zmmB, anyptr_gpC); 4897 e->vpermt2q(xmmA, xmmB, xmmC); 4898 e->vpermt2q(xmmA, xmmB, anyptr_gpC); 4899 e->vpermt2q(ymmA, ymmB, ymmC); 4900 e->vpermt2q(ymmA, ymmB, anyptr_gpC); 4901 e->vpermt2q(zmmA, zmmB, zmmC); 4902 e->vpermt2q(zmmA, zmmB, anyptr_gpC); 4903 e->vpermt2w(xmmA, xmmB, xmmC); 4904 e->vpermt2w(xmmA, xmmB, anyptr_gpC); 4905 e->vpermt2w(ymmA, ymmB, ymmC); 4906 e->vpermt2w(ymmA, ymmB, anyptr_gpC); 4907 e->vpermt2w(zmmA, zmmB, zmmC); 4908 e->vpermt2w(zmmA, zmmB, anyptr_gpC); 4909 e->vpermw(xmmA, xmmB, xmmC); 4910 e->vpermw(xmmA, xmmB, anyptr_gpC); 4911 e->vpermw(ymmA, ymmB, ymmC); 4912 e->vpermw(ymmA, ymmB, anyptr_gpC); 4913 e->vpermw(zmmA, zmmB, zmmC); 4914 e->vpermw(zmmA, zmmB, anyptr_gpC); 4915 e->vpexpandd(xmmA, xmmB); 4916 e->vpexpandd(xmmA, anyptr_gpB); 4917 e->vpexpandd(ymmA, ymmB); 4918 e->vpexpandd(ymmA, anyptr_gpB); 4919 e->vpexpandd(zmmA, zmmB); 4920 e->vpexpandd(zmmA, anyptr_gpB); 4921 e->vpexpandq(xmmA, xmmB); 4922 e->vpexpandq(xmmA, anyptr_gpB); 4923 e->vpexpandq(ymmA, ymmB); 4924 e->vpexpandq(ymmA, anyptr_gpB); 4925 e->vpexpandq(zmmA, zmmB); 4926 e->vpexpandq(zmmA, anyptr_gpB); 4927 e->vpextrb(gdA, xmmB, 0); 4928 e->vpextrb(anyptr_gpA, xmmB, 0); 4929 e->vpextrb(gzA, xmmB, 0); 4930 e->vpextrd(gdA, xmmB, 0); 4931 e->vpextrd(anyptr_gpA, xmmB, 0); 4932 if (isX64) e->vpextrd(gzA, xmmB, 0); 4933 if (isX64) e->vpextrq(gzA, xmmB, 0); 4934 e->vpextrq(anyptr_gpA, xmmB, 0); 4935 e->vpextrw(gdA, xmmB, 0); 4936 e->vpextrw(gzA, xmmB, 0); 4937 e->vpextrw(gdA, xmmB, 0); 4938 e->vpextrw(anyptr_gpA, xmmB, 0); 4939 e->vpextrw(gzA, xmmB, 0); 4940 e->vpgatherdd(xmmA, vx_ptr); 4941 e->vpgatherdd(ymmA, vy_ptr); 4942 e->vpgatherdd(zmmA, vz_ptr); 4943 e->vpgatherdq(xmmA, vx_ptr); 4944 e->vpgatherdq(ymmA, vy_ptr); 4945 e->vpgatherdq(zmmA, vz_ptr); 4946 e->vpgatherqd(xmmA, vx_ptr); 4947 e->vpgatherqd(ymmA, vy_ptr); 4948 e->vpgatherqd(zmmA, vz_ptr); 4949 e->vpgatherqq(xmmA, vx_ptr); 4950 e->vpgatherqq(ymmA, vy_ptr); 4951 e->vpgatherqq(zmmA, vz_ptr); 4952 e->vpinsrb(xmmA, xmmB, gdC, 0); 4953 e->vpinsrb(xmmA, xmmB, anyptr_gpC, 0); 4954 e->vpinsrb(xmmA, xmmB, gzC, 0); 4955 e->vpinsrd(xmmA, xmmB, gdC, 0); 4956 e->vpinsrd(xmmA, xmmB, anyptr_gpC, 0); 4957 e->vpinsrd(xmmA, xmmB, gzC, 0); 4958 if (isX64) e->vpinsrq(xmmA, xmmB, gzC, 0); 4959 e->vpinsrq(xmmA, xmmB, anyptr_gpC, 0); 4960 e->vpinsrw(xmmA, xmmB, gdC, 0); 4961 e->vpinsrw(xmmA, xmmB, anyptr_gpC, 0); 4962 e->vpinsrw(xmmA, xmmB, gzC, 0); 4963 e->vplzcntd(xmmA, xmmB); 4964 e->vplzcntd(xmmA, anyptr_gpB); 4965 e->vplzcntd(ymmA, ymmB); 4966 e->vplzcntd(ymmA, anyptr_gpB); 4967 e->vplzcntd(zmmA, zmmB); 4968 e->vplzcntd(zmmA, anyptr_gpB); 4969 e->vplzcntq(xmmA, xmmB); 4970 e->vplzcntq(xmmA, anyptr_gpB); 4971 e->vplzcntq(ymmA, ymmB); 4972 e->vplzcntq(ymmA, anyptr_gpB); 4973 e->vplzcntq(zmmA, zmmB); 4974 e->vplzcntq(zmmA, anyptr_gpB); 4975 e->vpmadd52huq(xmmA, xmmB, xmmC); 4976 e->vpmadd52huq(xmmA, xmmB, anyptr_gpC); 4977 e->vpmadd52huq(ymmA, ymmB, ymmC); 4978 e->vpmadd52huq(ymmA, ymmB, anyptr_gpC); 4979 e->vpmadd52huq(zmmA, zmmB, zmmC); 4980 e->vpmadd52huq(zmmA, zmmB, anyptr_gpC); 4981 e->vpmadd52luq(xmmA, xmmB, xmmC); 4982 e->vpmadd52luq(xmmA, xmmB, anyptr_gpC); 4983 e->vpmadd52luq(ymmA, ymmB, ymmC); 4984 e->vpmadd52luq(ymmA, ymmB, anyptr_gpC); 4985 e->vpmadd52luq(zmmA, zmmB, zmmC); 4986 e->vpmadd52luq(zmmA, zmmB, anyptr_gpC); 4987 e->vpmaddubsw(xmmA, xmmB, xmmC); 4988 e->vpmaddubsw(xmmA, xmmB, anyptr_gpC); 4989 e->vpmaddubsw(ymmA, ymmB, ymmC); 4990 e->vpmaddubsw(ymmA, ymmB, anyptr_gpC); 4991 e->vpmaddubsw(zmmA, zmmB, zmmC); 4992 e->vpmaddubsw(zmmA, zmmB, anyptr_gpC); 4993 e->vpmaddwd(xmmA, xmmB, xmmC); 4994 e->vpmaddwd(xmmA, xmmB, anyptr_gpC); 4995 e->vpmaddwd(ymmA, ymmB, ymmC); 4996 e->vpmaddwd(ymmA, ymmB, anyptr_gpC); 4997 e->vpmaddwd(zmmA, zmmB, zmmC); 4998 e->vpmaddwd(zmmA, zmmB, anyptr_gpC); 4999 e->vpmaxsb(xmmA, xmmB, xmmC); 5000 e->vpmaxsb(xmmA, xmmB, anyptr_gpC); 5001 e->vpmaxsb(ymmA, ymmB, ymmC); 5002 e->vpmaxsb(ymmA, ymmB, anyptr_gpC); 5003 e->vpmaxsb(zmmA, zmmB, zmmC); 5004 e->vpmaxsb(zmmA, zmmB, anyptr_gpC); 5005 e->vpmaxsd(xmmA, xmmB, xmmC); 5006 e->vpmaxsd(xmmA, xmmB, anyptr_gpC); 5007 e->vpmaxsd(ymmA, ymmB, ymmC); 5008 e->vpmaxsd(ymmA, ymmB, anyptr_gpC); 5009 e->vpmaxsd(zmmA, zmmB, zmmC); 5010 e->vpmaxsd(zmmA, zmmB, anyptr_gpC); 5011 e->vpmaxsq(xmmA, xmmB, xmmC); 5012 e->vpmaxsq(xmmA, xmmB, anyptr_gpC); 5013 e->vpmaxsq(ymmA, ymmB, ymmC); 5014 e->vpmaxsq(ymmA, ymmB, anyptr_gpC); 5015 e->vpmaxsq(zmmA, zmmB, zmmC); 5016 e->vpmaxsq(zmmA, zmmB, anyptr_gpC); 5017 e->vpmaxsw(xmmA, xmmB, xmmC); 5018 e->vpmaxsw(xmmA, xmmB, anyptr_gpC); 5019 e->vpmaxsw(ymmA, ymmB, ymmC); 5020 e->vpmaxsw(ymmA, ymmB, anyptr_gpC); 5021 e->vpmaxsw(zmmA, zmmB, zmmC); 5022 e->vpmaxsw(zmmA, zmmB, anyptr_gpC); 5023 e->vpmaxub(xmmA, xmmB, xmmC); 5024 e->vpmaxub(xmmA, xmmB, anyptr_gpC); 5025 e->vpmaxub(ymmA, ymmB, ymmC); 5026 e->vpmaxub(ymmA, ymmB, anyptr_gpC); 5027 e->vpmaxub(zmmA, zmmB, zmmC); 5028 e->vpmaxub(zmmA, zmmB, anyptr_gpC); 5029 e->vpmaxud(xmmA, xmmB, xmmC); 5030 e->vpmaxud(xmmA, xmmB, anyptr_gpC); 5031 e->vpmaxud(ymmA, ymmB, ymmC); 5032 e->vpmaxud(ymmA, ymmB, anyptr_gpC); 5033 e->vpmaxud(zmmA, zmmB, zmmC); 5034 e->vpmaxud(zmmA, zmmB, anyptr_gpC); 5035 e->vpmaxuq(xmmA, xmmB, xmmC); 5036 e->vpmaxuq(xmmA, xmmB, anyptr_gpC); 5037 e->vpmaxuq(ymmA, ymmB, ymmC); 5038 e->vpmaxuq(ymmA, ymmB, anyptr_gpC); 5039 e->vpmaxuq(zmmA, zmmB, zmmC); 5040 e->vpmaxuq(zmmA, zmmB, anyptr_gpC); 5041 e->vpmaxuw(xmmA, xmmB, xmmC); 5042 e->vpmaxuw(xmmA, xmmB, anyptr_gpC); 5043 e->vpmaxuw(ymmA, ymmB, ymmC); 5044 e->vpmaxuw(ymmA, ymmB, anyptr_gpC); 5045 e->vpmaxuw(zmmA, zmmB, zmmC); 5046 e->vpmaxuw(zmmA, zmmB, anyptr_gpC); 5047 e->vpminsb(xmmA, xmmB, xmmC); 5048 e->vpminsb(xmmA, xmmB, anyptr_gpC); 5049 e->vpminsb(ymmA, ymmB, ymmC); 5050 e->vpminsb(ymmA, ymmB, anyptr_gpC); 5051 e->vpminsb(zmmA, zmmB, zmmC); 5052 e->vpminsb(zmmA, zmmB, anyptr_gpC); 5053 e->vpminsd(xmmA, xmmB, xmmC); 5054 e->vpminsd(xmmA, xmmB, anyptr_gpC); 5055 e->vpminsd(ymmA, ymmB, ymmC); 5056 e->vpminsd(ymmA, ymmB, anyptr_gpC); 5057 e->vpminsd(zmmA, zmmB, zmmC); 5058 e->vpminsd(zmmA, zmmB, anyptr_gpC); 5059 e->vpminsq(xmmA, xmmB, xmmC); 5060 e->vpminsq(xmmA, xmmB, anyptr_gpC); 5061 e->vpminsq(ymmA, ymmB, ymmC); 5062 e->vpminsq(ymmA, ymmB, anyptr_gpC); 5063 e->vpminsq(zmmA, zmmB, zmmC); 5064 e->vpminsq(zmmA, zmmB, anyptr_gpC); 5065 e->vpminsw(xmmA, xmmB, xmmC); 5066 e->vpminsw(xmmA, xmmB, anyptr_gpC); 5067 e->vpminsw(ymmA, ymmB, ymmC); 5068 e->vpminsw(ymmA, ymmB, anyptr_gpC); 5069 e->vpminsw(zmmA, zmmB, zmmC); 5070 e->vpminsw(zmmA, zmmB, anyptr_gpC); 5071 e->vpminub(xmmA, xmmB, xmmC); 5072 e->vpminub(xmmA, xmmB, anyptr_gpC); 5073 e->vpminub(ymmA, ymmB, ymmC); 5074 e->vpminub(ymmA, ymmB, anyptr_gpC); 5075 e->vpminub(zmmA, zmmB, zmmC); 5076 e->vpminub(zmmA, zmmB, anyptr_gpC); 5077 e->vpminud(xmmA, xmmB, xmmC); 5078 e->vpminud(xmmA, xmmB, anyptr_gpC); 5079 e->vpminud(ymmA, ymmB, ymmC); 5080 e->vpminud(ymmA, ymmB, anyptr_gpC); 5081 e->vpminud(zmmA, zmmB, zmmC); 5082 e->vpminud(zmmA, zmmB, anyptr_gpC); 5083 e->vpminuq(xmmA, xmmB, xmmC); 5084 e->vpminuq(xmmA, xmmB, anyptr_gpC); 5085 e->vpminuq(ymmA, ymmB, ymmC); 5086 e->vpminuq(ymmA, ymmB, anyptr_gpC); 5087 e->vpminuq(zmmA, zmmB, zmmC); 5088 e->vpminuq(zmmA, zmmB, anyptr_gpC); 5089 e->vpminuw(xmmA, xmmB, xmmC); 5090 e->vpminuw(xmmA, xmmB, anyptr_gpC); 5091 e->vpminuw(ymmA, ymmB, ymmC); 5092 e->vpminuw(ymmA, ymmB, anyptr_gpC); 5093 e->vpminuw(zmmA, zmmB, zmmC); 5094 e->vpminuw(zmmA, zmmB, anyptr_gpC); 5095 e->vpmovb2m(kA, xmmB); 5096 e->vpmovb2m(kA, ymmB); 5097 e->vpmovb2m(kA, zmmB); 5098 e->vpmovd2m(kA, xmmB); 5099 e->vpmovd2m(kA, ymmB); 5100 e->vpmovd2m(kA, zmmB); 5101 e->vpmovdb(xmmA, xmmB); 5102 e->vpmovdb(anyptr_gpA, xmmB); 5103 e->vpmovdb(xmmA, ymmB); 5104 e->vpmovdb(anyptr_gpA, ymmB); 5105 e->vpmovdb(xmmA, zmmB); 5106 e->vpmovdb(anyptr_gpA, zmmB); 5107 e->vpmovdw(xmmA, xmmB); 5108 e->vpmovdw(anyptr_gpA, xmmB); 5109 e->vpmovdw(xmmA, ymmB); 5110 e->vpmovdw(anyptr_gpA, ymmB); 5111 e->vpmovdw(ymmA, zmmB); 5112 e->vpmovdw(anyptr_gpA, zmmB); 5113 e->vpmovm2b(xmmA, kB); 5114 e->vpmovm2b(ymmA, kB); 5115 e->vpmovm2b(zmmA, kB); 5116 e->vpmovm2d(xmmA, kB); 5117 e->vpmovm2d(ymmA, kB); 5118 e->vpmovm2d(zmmA, kB); 5119 e->vpmovm2q(xmmA, kB); 5120 e->vpmovm2q(ymmA, kB); 5121 e->vpmovm2q(zmmA, kB); 5122 e->vpmovm2w(xmmA, kB); 5123 e->vpmovm2w(ymmA, kB); 5124 e->vpmovm2w(zmmA, kB); 5125 e->vpmovq2m(kA, xmmB); 5126 e->vpmovq2m(kA, ymmB); 5127 e->vpmovq2m(kA, zmmB); 5128 e->vpmovqb(xmmA, xmmB); 5129 e->vpmovqb(anyptr_gpA, xmmB); 5130 e->vpmovqb(xmmA, ymmB); 5131 e->vpmovqb(anyptr_gpA, ymmB); 5132 e->vpmovqb(xmmA, zmmB); 5133 e->vpmovqb(anyptr_gpA, zmmB); 5134 e->vpmovqd(xmmA, xmmB); 5135 e->vpmovqd(anyptr_gpA, xmmB); 5136 e->vpmovqd(xmmA, ymmB); 5137 e->vpmovqd(anyptr_gpA, ymmB); 5138 e->vpmovqd(ymmA, zmmB); 5139 e->vpmovqd(anyptr_gpA, zmmB); 5140 e->vpmovqw(xmmA, xmmB); 5141 e->vpmovqw(anyptr_gpA, xmmB); 5142 e->vpmovqw(xmmA, ymmB); 5143 e->vpmovqw(anyptr_gpA, ymmB); 5144 e->vpmovqw(xmmA, zmmB); 5145 e->vpmovqw(anyptr_gpA, zmmB); 5146 e->vpmovsdb(xmmA, xmmB); 5147 e->vpmovsdb(anyptr_gpA, xmmB); 5148 e->vpmovsdb(xmmA, ymmB); 5149 e->vpmovsdb(anyptr_gpA, ymmB); 5150 e->vpmovsdb(xmmA, zmmB); 5151 e->vpmovsdb(anyptr_gpA, zmmB); 5152 e->vpmovsdw(xmmA, xmmB); 5153 e->vpmovsdw(anyptr_gpA, xmmB); 5154 e->vpmovsdw(xmmA, ymmB); 5155 e->vpmovsdw(anyptr_gpA, ymmB); 5156 e->vpmovsdw(ymmA, zmmB); 5157 e->vpmovsdw(anyptr_gpA, zmmB); 5158 e->vpmovsqb(xmmA, xmmB); 5159 e->vpmovsqb(anyptr_gpA, xmmB); 5160 e->vpmovsqb(xmmA, ymmB); 5161 e->vpmovsqb(anyptr_gpA, ymmB); 5162 e->vpmovsqb(xmmA, zmmB); 5163 e->vpmovsqb(anyptr_gpA, zmmB); 5164 e->vpmovsqd(xmmA, xmmB); 5165 e->vpmovsqd(anyptr_gpA, xmmB); 5166 e->vpmovsqd(xmmA, ymmB); 5167 e->vpmovsqd(anyptr_gpA, ymmB); 5168 e->vpmovsqd(ymmA, zmmB); 5169 e->vpmovsqd(anyptr_gpA, zmmB); 5170 e->vpmovsqw(xmmA, xmmB); 5171 e->vpmovsqw(anyptr_gpA, xmmB); 5172 e->vpmovsqw(xmmA, ymmB); 5173 e->vpmovsqw(anyptr_gpA, ymmB); 5174 e->vpmovsqw(xmmA, zmmB); 5175 e->vpmovsqw(anyptr_gpA, zmmB); 5176 e->vpmovswb(xmmA, xmmB); 5177 e->vpmovswb(anyptr_gpA, xmmB); 5178 e->vpmovswb(xmmA, ymmB); 5179 e->vpmovswb(anyptr_gpA, ymmB); 5180 e->vpmovswb(ymmA, zmmB); 5181 e->vpmovswb(anyptr_gpA, zmmB); 5182 e->vpmovsxbd(xmmA, xmmB); 5183 e->vpmovsxbd(xmmA, anyptr_gpB); 5184 e->vpmovsxbd(ymmA, xmmB); 5185 e->vpmovsxbd(ymmA, anyptr_gpB); 5186 e->vpmovsxbd(zmmA, xmmB); 5187 e->vpmovsxbd(zmmA, anyptr_gpB); 5188 e->vpmovsxbq(xmmA, xmmB); 5189 e->vpmovsxbq(xmmA, anyptr_gpB); 5190 e->vpmovsxbq(ymmA, xmmB); 5191 e->vpmovsxbq(ymmA, anyptr_gpB); 5192 e->vpmovsxbq(zmmA, xmmB); 5193 e->vpmovsxbq(zmmA, anyptr_gpB); 5194 e->vpmovsxbw(xmmA, xmmB); 5195 e->vpmovsxbw(xmmA, anyptr_gpB); 5196 e->vpmovsxbw(ymmA, xmmB); 5197 e->vpmovsxbw(ymmA, anyptr_gpB); 5198 e->vpmovsxbw(zmmA, ymmB); 5199 e->vpmovsxbw(zmmA, anyptr_gpB); 5200 e->vpmovsxdq(xmmA, xmmB); 5201 e->vpmovsxdq(xmmA, anyptr_gpB); 5202 e->vpmovsxdq(ymmA, xmmB); 5203 e->vpmovsxdq(ymmA, anyptr_gpB); 5204 e->vpmovsxdq(zmmA, ymmB); 5205 e->vpmovsxdq(zmmA, anyptr_gpB); 5206 e->vpmovsxwd(xmmA, xmmB); 5207 e->vpmovsxwd(xmmA, anyptr_gpB); 5208 e->vpmovsxwd(ymmA, xmmB); 5209 e->vpmovsxwd(ymmA, anyptr_gpB); 5210 e->vpmovsxwd(zmmA, ymmB); 5211 e->vpmovsxwd(zmmA, anyptr_gpB); 5212 e->vpmovsxwq(xmmA, xmmB); 5213 e->vpmovsxwq(xmmA, anyptr_gpB); 5214 e->vpmovsxwq(ymmA, xmmB); 5215 e->vpmovsxwq(ymmA, anyptr_gpB); 5216 e->vpmovsxwq(zmmA, xmmB); 5217 e->vpmovsxwq(zmmA, anyptr_gpB); 5218 e->vpmovusdb(xmmA, xmmB); 5219 e->vpmovusdb(anyptr_gpA, xmmB); 5220 e->vpmovusdb(xmmA, ymmB); 5221 e->vpmovusdb(anyptr_gpA, ymmB); 5222 e->vpmovusdb(xmmA, zmmB); 5223 e->vpmovusdb(anyptr_gpA, zmmB); 5224 e->vpmovusdw(xmmA, xmmB); 5225 e->vpmovusdw(anyptr_gpA, xmmB); 5226 e->vpmovusdw(xmmA, ymmB); 5227 e->vpmovusdw(anyptr_gpA, ymmB); 5228 e->vpmovusdw(ymmA, zmmB); 5229 e->vpmovusdw(anyptr_gpA, zmmB); 5230 e->vpmovusqb(xmmA, xmmB); 5231 e->vpmovusqb(anyptr_gpA, xmmB); 5232 e->vpmovusqb(xmmA, ymmB); 5233 e->vpmovusqb(anyptr_gpA, ymmB); 5234 e->vpmovusqb(xmmA, zmmB); 5235 e->vpmovusqb(anyptr_gpA, zmmB); 5236 e->vpmovusqd(xmmA, xmmB); 5237 e->vpmovusqd(anyptr_gpA, xmmB); 5238 e->vpmovusqd(xmmA, ymmB); 5239 e->vpmovusqd(anyptr_gpA, ymmB); 5240 e->vpmovusqd(ymmA, zmmB); 5241 e->vpmovusqd(anyptr_gpA, zmmB); 5242 e->vpmovusqw(xmmA, xmmB); 5243 e->vpmovusqw(anyptr_gpA, xmmB); 5244 e->vpmovusqw(xmmA, ymmB); 5245 e->vpmovusqw(anyptr_gpA, ymmB); 5246 e->vpmovusqw(xmmA, zmmB); 5247 e->vpmovusqw(anyptr_gpA, zmmB); 5248 e->vpmovuswb(xmmA, xmmB); 5249 e->vpmovuswb(anyptr_gpA, xmmB); 5250 e->vpmovuswb(xmmA, ymmB); 5251 e->vpmovuswb(anyptr_gpA, ymmB); 5252 e->vpmovuswb(ymmA, zmmB); 5253 e->vpmovuswb(anyptr_gpA, zmmB); 5254 e->vpmovw2m(kA, xmmB); 5255 e->vpmovw2m(kA, ymmB); 5256 e->vpmovw2m(kA, zmmB); 5257 e->vpmovwb(xmmA, xmmB); 5258 e->vpmovwb(anyptr_gpA, xmmB); 5259 e->vpmovwb(xmmA, ymmB); 5260 e->vpmovwb(anyptr_gpA, ymmB); 5261 e->vpmovwb(ymmA, zmmB); 5262 e->vpmovwb(anyptr_gpA, zmmB); 5263 e->vpmovzxbd(xmmA, xmmB); 5264 e->vpmovzxbd(xmmA, anyptr_gpB); 5265 e->vpmovzxbd(ymmA, xmmB); 5266 e->vpmovzxbd(ymmA, anyptr_gpB); 5267 e->vpmovzxbd(zmmA, xmmB); 5268 e->vpmovzxbd(zmmA, anyptr_gpB); 5269 e->vpmovzxbq(xmmA, xmmB); 5270 e->vpmovzxbq(xmmA, anyptr_gpB); 5271 e->vpmovzxbq(ymmA, xmmB); 5272 e->vpmovzxbq(ymmA, anyptr_gpB); 5273 e->vpmovzxbq(zmmA, xmmB); 5274 e->vpmovzxbq(zmmA, anyptr_gpB); 5275 e->vpmovzxbw(xmmA, xmmB); 5276 e->vpmovzxbw(xmmA, anyptr_gpB); 5277 e->vpmovzxbw(ymmA, xmmB); 5278 e->vpmovzxbw(ymmA, anyptr_gpB); 5279 e->vpmovzxbw(zmmA, ymmB); 5280 e->vpmovzxbw(zmmA, anyptr_gpB); 5281 e->vpmovzxdq(xmmA, xmmB); 5282 e->vpmovzxdq(xmmA, anyptr_gpB); 5283 e->vpmovzxdq(ymmA, xmmB); 5284 e->vpmovzxdq(ymmA, anyptr_gpB); 5285 e->vpmovzxdq(zmmA, ymmB); 5286 e->vpmovzxdq(zmmA, anyptr_gpB); 5287 e->vpmovzxwd(xmmA, xmmB); 5288 e->vpmovzxwd(xmmA, anyptr_gpB); 5289 e->vpmovzxwd(ymmA, xmmB); 5290 e->vpmovzxwd(ymmA, anyptr_gpB); 5291 e->vpmovzxwd(zmmA, ymmB); 5292 e->vpmovzxwd(zmmA, anyptr_gpB); 5293 e->vpmovzxwq(xmmA, xmmB); 5294 e->vpmovzxwq(xmmA, anyptr_gpB); 5295 e->vpmovzxwq(ymmA, xmmB); 5296 e->vpmovzxwq(ymmA, anyptr_gpB); 5297 e->vpmovzxwq(zmmA, xmmB); 5298 e->vpmovzxwq(zmmA, anyptr_gpB); 5299 e->vpmuldq(xmmA, xmmB, xmmC); 5300 e->vpmuldq(xmmA, xmmB, anyptr_gpC); 5301 e->vpmuldq(ymmA, ymmB, ymmC); 5302 e->vpmuldq(ymmA, ymmB, anyptr_gpC); 5303 e->vpmuldq(zmmA, zmmB, zmmC); 5304 e->vpmuldq(zmmA, zmmB, anyptr_gpC); 5305 e->vpmulhrsw(xmmA, xmmB, xmmC); 5306 e->vpmulhrsw(xmmA, xmmB, anyptr_gpC); 5307 e->vpmulhrsw(ymmA, ymmB, ymmC); 5308 e->vpmulhrsw(ymmA, ymmB, anyptr_gpC); 5309 e->vpmulhrsw(zmmA, zmmB, zmmC); 5310 e->vpmulhrsw(zmmA, zmmB, anyptr_gpC); 5311 e->vpmulhuw(xmmA, xmmB, xmmC); 5312 e->vpmulhuw(xmmA, xmmB, anyptr_gpC); 5313 e->vpmulhuw(ymmA, ymmB, ymmC); 5314 e->vpmulhuw(ymmA, ymmB, anyptr_gpC); 5315 e->vpmulhuw(zmmA, zmmB, zmmC); 5316 e->vpmulhuw(zmmA, zmmB, anyptr_gpC); 5317 e->vpmulhw(xmmA, xmmB, xmmC); 5318 e->vpmulhw(xmmA, xmmB, anyptr_gpC); 5319 e->vpmulhw(ymmA, ymmB, ymmC); 5320 e->vpmulhw(ymmA, ymmB, anyptr_gpC); 5321 e->vpmulhw(zmmA, zmmB, zmmC); 5322 e->vpmulhw(zmmA, zmmB, anyptr_gpC); 5323 e->vpmulld(xmmA, xmmB, xmmC); 5324 e->vpmulld(xmmA, xmmB, anyptr_gpC); 5325 e->vpmulld(ymmA, ymmB, ymmC); 5326 e->vpmulld(ymmA, ymmB, anyptr_gpC); 5327 e->vpmulld(zmmA, zmmB, zmmC); 5328 e->vpmulld(zmmA, zmmB, anyptr_gpC); 5329 e->vpmullq(xmmA, xmmB, xmmC); 5330 e->vpmullq(xmmA, xmmB, anyptr_gpC); 5331 e->vpmullq(ymmA, ymmB, ymmC); 5332 e->vpmullq(ymmA, ymmB, anyptr_gpC); 5333 e->vpmullq(zmmA, zmmB, zmmC); 5334 e->vpmullq(zmmA, zmmB, anyptr_gpC); 5335 e->vpmullw(xmmA, xmmB, xmmC); 5336 e->vpmullw(xmmA, xmmB, anyptr_gpC); 5337 e->vpmullw(ymmA, ymmB, ymmC); 5338 e->vpmullw(ymmA, ymmB, anyptr_gpC); 5339 e->vpmullw(zmmA, zmmB, zmmC); 5340 e->vpmullw(zmmA, zmmB, anyptr_gpC); 5341 e->vpmultishiftqb(xmmA, xmmB, xmmC); 5342 e->vpmultishiftqb(xmmA, xmmB, anyptr_gpC); 5343 e->vpmultishiftqb(ymmA, ymmB, ymmC); 5344 e->vpmultishiftqb(ymmA, ymmB, anyptr_gpC); 5345 e->vpmultishiftqb(zmmA, zmmB, zmmC); 5346 e->vpmultishiftqb(zmmA, zmmB, anyptr_gpC); 5347 e->vpmuludq(xmmA, xmmB, xmmC); 5348 e->vpmuludq(xmmA, xmmB, anyptr_gpC); 5349 e->vpmuludq(ymmA, ymmB, ymmC); 5350 e->vpmuludq(ymmA, ymmB, anyptr_gpC); 5351 e->vpmuludq(zmmA, zmmB, zmmC); 5352 e->vpmuludq(zmmA, zmmB, anyptr_gpC); 5353 e->vpopcntd(zmmA, zmmB); 5354 e->vpopcntd(zmmA, anyptr_gpB); 5355 e->vpopcntq(zmmA, zmmB); 5356 e->vpopcntq(zmmA, anyptr_gpB); 5357 e->vpord(xmmA, xmmB, xmmC); 5358 e->vpord(xmmA, xmmB, anyptr_gpC); 5359 e->vpord(ymmA, ymmB, ymmC); 5360 e->vpord(ymmA, ymmB, anyptr_gpC); 5361 e->vpord(zmmA, zmmB, zmmC); 5362 e->vpord(zmmA, zmmB, anyptr_gpC); 5363 e->vporq(xmmA, xmmB, xmmC); 5364 e->vporq(xmmA, xmmB, anyptr_gpC); 5365 e->vporq(ymmA, ymmB, ymmC); 5366 e->vporq(ymmA, ymmB, anyptr_gpC); 5367 e->vporq(zmmA, zmmB, zmmC); 5368 e->vporq(zmmA, zmmB, anyptr_gpC); 5369 e->vprold(xmmA, xmmB, 0); 5370 e->vprold(xmmA, anyptr_gpB, 0); 5371 e->vprold(ymmA, ymmB, 0); 5372 e->vprold(ymmA, anyptr_gpB, 0); 5373 e->vprold(zmmA, zmmB, 0); 5374 e->vprold(zmmA, anyptr_gpB, 0); 5375 e->vprolq(xmmA, xmmB, 0); 5376 e->vprolq(xmmA, anyptr_gpB, 0); 5377 e->vprolq(ymmA, ymmB, 0); 5378 e->vprolq(ymmA, anyptr_gpB, 0); 5379 e->vprolq(zmmA, zmmB, 0); 5380 e->vprolq(zmmA, anyptr_gpB, 0); 5381 e->vprolvd(xmmA, xmmB, xmmC); 5382 e->vprolvd(xmmA, xmmB, anyptr_gpC); 5383 e->vprolvd(ymmA, ymmB, ymmC); 5384 e->vprolvd(ymmA, ymmB, anyptr_gpC); 5385 e->vprolvd(zmmA, zmmB, zmmC); 5386 e->vprolvd(zmmA, zmmB, anyptr_gpC); 5387 e->vprolvq(xmmA, xmmB, xmmC); 5388 e->vprolvq(xmmA, xmmB, anyptr_gpC); 5389 e->vprolvq(ymmA, ymmB, ymmC); 5390 e->vprolvq(ymmA, ymmB, anyptr_gpC); 5391 e->vprolvq(zmmA, zmmB, zmmC); 5392 e->vprolvq(zmmA, zmmB, anyptr_gpC); 5393 e->vprord(xmmA, xmmB, 0); 5394 e->vprord(xmmA, anyptr_gpB, 0); 5395 e->vprord(ymmA, ymmB, 0); 5396 e->vprord(ymmA, anyptr_gpB, 0); 5397 e->vprord(zmmA, zmmB, 0); 5398 e->vprord(zmmA, anyptr_gpB, 0); 5399 e->vprorq(xmmA, xmmB, 0); 5400 e->vprorq(xmmA, anyptr_gpB, 0); 5401 e->vprorq(ymmA, ymmB, 0); 5402 e->vprorq(ymmA, anyptr_gpB, 0); 5403 e->vprorq(zmmA, zmmB, 0); 5404 e->vprorq(zmmA, anyptr_gpB, 0); 5405 e->vprorvd(xmmA, xmmB, xmmC); 5406 e->vprorvd(xmmA, xmmB, anyptr_gpC); 5407 e->vprorvd(ymmA, ymmB, ymmC); 5408 e->vprorvd(ymmA, ymmB, anyptr_gpC); 5409 e->vprorvd(zmmA, zmmB, zmmC); 5410 e->vprorvd(zmmA, zmmB, anyptr_gpC); 5411 e->vprorvq(xmmA, xmmB, xmmC); 5412 e->vprorvq(xmmA, xmmB, anyptr_gpC); 5413 e->vprorvq(ymmA, ymmB, ymmC); 5414 e->vprorvq(ymmA, ymmB, anyptr_gpC); 5415 e->vprorvq(zmmA, zmmB, zmmC); 5416 e->vprorvq(zmmA, zmmB, anyptr_gpC); 5417 e->vpsadbw(xmmA, xmmB, xmmC); 5418 e->vpsadbw(xmmA, xmmB, anyptr_gpC); 5419 e->vpsadbw(ymmA, ymmB, ymmC); 5420 e->vpsadbw(ymmA, ymmB, anyptr_gpC); 5421 e->vpsadbw(zmmA, zmmB, zmmC); 5422 e->vpsadbw(zmmA, zmmB, anyptr_gpC); 5423 e->vpscatterdd(vx_ptr, xmmB); 5424 e->vpscatterdd(vy_ptr, ymmB); 5425 e->vpscatterdd(vz_ptr, zmmB); 5426 e->vpscatterdq(vx_ptr, xmmB); 5427 e->vpscatterdq(vy_ptr, ymmB); 5428 e->vpscatterdq(vz_ptr, zmmB); 5429 e->vpscatterqd(vx_ptr, xmmB); 5430 e->vpscatterqd(vy_ptr, xmmB); 5431 e->vpscatterqd(vz_ptr, ymmB); 5432 e->vpscatterqq(vx_ptr, xmmB); 5433 e->vpscatterqq(vy_ptr, ymmB); 5434 e->vpscatterqq(vz_ptr, zmmB); 5435 e->vpshufb(xmmA, xmmB, xmmC); 5436 e->vpshufb(xmmA, xmmB, anyptr_gpC); 5437 e->vpshufb(ymmA, ymmB, ymmC); 5438 e->vpshufb(ymmA, ymmB, anyptr_gpC); 5439 e->vpshufb(zmmA, zmmB, zmmC); 5440 e->vpshufb(zmmA, zmmB, anyptr_gpC); 5441 e->vpshufd(xmmA, xmmB, 0); 5442 e->vpshufd(xmmA, anyptr_gpB, 0); 5443 e->vpshufd(ymmA, ymmB, 0); 5444 e->vpshufd(ymmA, anyptr_gpB, 0); 5445 e->vpshufd(zmmA, zmmB, 0); 5446 e->vpshufd(zmmA, anyptr_gpB, 0); 5447 e->vpshufhw(xmmA, xmmB, 0); 5448 e->vpshufhw(xmmA, anyptr_gpB, 0); 5449 e->vpshufhw(ymmA, ymmB, 0); 5450 e->vpshufhw(ymmA, anyptr_gpB, 0); 5451 e->vpshufhw(zmmA, zmmB, 0); 5452 e->vpshufhw(zmmA, anyptr_gpB, 0); 5453 e->vpshuflw(xmmA, xmmB, 0); 5454 e->vpshuflw(xmmA, anyptr_gpB, 0); 5455 e->vpshuflw(ymmA, ymmB, 0); 5456 e->vpshuflw(ymmA, anyptr_gpB, 0); 5457 e->vpshuflw(zmmA, zmmB, 0); 5458 e->vpshuflw(zmmA, anyptr_gpB, 0); 5459 e->vpslld(xmmA, xmmB, xmmC); 5460 e->vpslld(xmmA, xmmB, anyptr_gpC); 5461 e->vpslld(xmmA, xmmB, 0); 5462 e->vpslld(xmmA, anyptr_gpB, 0); 5463 e->vpslld(ymmA, ymmB, xmmC); 5464 e->vpslld(ymmA, ymmB, anyptr_gpC); 5465 e->vpslld(ymmA, ymmB, 0); 5466 e->vpslld(ymmA, anyptr_gpB, 0); 5467 e->vpslld(zmmA, zmmB, xmmC); 5468 e->vpslld(zmmA, zmmB, anyptr_gpC); 5469 e->vpslld(zmmA, zmmB, 0); 5470 e->vpslld(zmmA, anyptr_gpB, 0); 5471 e->vpslldq(xmmA, xmmB, 0); 5472 e->vpslldq(xmmA, anyptr_gpB, 0); 5473 e->vpslldq(ymmA, ymmB, 0); 5474 e->vpslldq(ymmA, anyptr_gpB, 0); 5475 e->vpslldq(zmmA, zmmB, 0); 5476 e->vpslldq(zmmA, anyptr_gpB, 0); 5477 e->vpsllq(xmmA, xmmB, xmmC); 5478 e->vpsllq(xmmA, xmmB, anyptr_gpC); 5479 e->vpsllq(xmmA, xmmB, 0); 5480 e->vpsllq(xmmA, anyptr_gpB, 0); 5481 e->vpsllq(ymmA, ymmB, xmmC); 5482 e->vpsllq(ymmA, ymmB, anyptr_gpC); 5483 e->vpsllq(ymmA, ymmB, 0); 5484 e->vpsllq(ymmA, anyptr_gpB, 0); 5485 e->vpsllq(zmmA, zmmB, xmmC); 5486 e->vpsllq(zmmA, zmmB, anyptr_gpC); 5487 e->vpsllq(zmmA, zmmB, 0); 5488 e->vpsllq(zmmA, anyptr_gpB, 0); 5489 e->vpsllvd(xmmA, xmmB, xmmC); 5490 e->vpsllvd(xmmA, xmmB, anyptr_gpC); 5491 e->vpsllvd(ymmA, ymmB, ymmC); 5492 e->vpsllvd(ymmA, ymmB, anyptr_gpC); 5493 e->vpsllvd(zmmA, zmmB, zmmC); 5494 e->vpsllvd(zmmA, zmmB, anyptr_gpC); 5495 e->vpsllvq(xmmA, xmmB, xmmC); 5496 e->vpsllvq(xmmA, xmmB, anyptr_gpC); 5497 e->vpsllvq(ymmA, ymmB, ymmC); 5498 e->vpsllvq(ymmA, ymmB, anyptr_gpC); 5499 e->vpsllvq(zmmA, zmmB, zmmC); 5500 e->vpsllvq(zmmA, zmmB, anyptr_gpC); 5501 e->vpsllvw(xmmA, xmmB, xmmC); 5502 e->vpsllvw(xmmA, xmmB, anyptr_gpC); 5503 e->vpsllvw(ymmA, ymmB, ymmC); 5504 e->vpsllvw(ymmA, ymmB, anyptr_gpC); 5505 e->vpsllvw(zmmA, zmmB, zmmC); 5506 e->vpsllvw(zmmA, zmmB, anyptr_gpC); 5507 e->vpsllw(xmmA, xmmB, xmmC); 5508 e->vpsllw(xmmA, xmmB, anyptr_gpC); 5509 e->vpsllw(xmmA, xmmB, 0); 5510 e->vpsllw(xmmA, anyptr_gpB, 0); 5511 e->vpsllw(ymmA, ymmB, xmmC); 5512 e->vpsllw(ymmA, ymmB, anyptr_gpC); 5513 e->vpsllw(ymmA, ymmB, 0); 5514 e->vpsllw(ymmA, anyptr_gpB, 0); 5515 e->vpsllw(zmmA, zmmB, xmmC); 5516 e->vpsllw(zmmA, zmmB, anyptr_gpC); 5517 e->vpsllw(zmmA, zmmB, 0); 5518 e->vpsllw(zmmA, anyptr_gpB, 0); 5519 e->vpsrad(xmmA, xmmB, xmmC); 5520 e->vpsrad(xmmA, xmmB, anyptr_gpC); 5521 e->vpsrad(xmmA, xmmB, 0); 5522 e->vpsrad(xmmA, anyptr_gpB, 0); 5523 e->vpsrad(ymmA, ymmB, xmmC); 5524 e->vpsrad(ymmA, ymmB, anyptr_gpC); 5525 e->vpsrad(ymmA, ymmB, 0); 5526 e->vpsrad(ymmA, anyptr_gpB, 0); 5527 e->vpsrad(zmmA, zmmB, xmmC); 5528 e->vpsrad(zmmA, zmmB, anyptr_gpC); 5529 e->vpsrad(zmmA, zmmB, 0); 5530 e->vpsrad(zmmA, anyptr_gpB, 0); 5531 e->vpsraq(xmmA, xmmB, xmmC); 5532 e->vpsraq(xmmA, xmmB, anyptr_gpC); 5533 e->vpsraq(xmmA, xmmB, 0); 5534 e->vpsraq(xmmA, anyptr_gpB, 0); 5535 e->vpsraq(ymmA, ymmB, xmmC); 5536 e->vpsraq(ymmA, ymmB, anyptr_gpC); 5537 e->vpsraq(ymmA, ymmB, 0); 5538 e->vpsraq(ymmA, anyptr_gpB, 0); 5539 e->vpsraq(zmmA, zmmB, xmmC); 5540 e->vpsraq(zmmA, zmmB, anyptr_gpC); 5541 e->vpsraq(zmmA, zmmB, 0); 5542 e->vpsraq(zmmA, anyptr_gpB, 0); 5543 e->vpsravd(xmmA, xmmB, xmmC); 5544 e->vpsravd(xmmA, xmmB, anyptr_gpC); 5545 e->vpsravd(ymmA, ymmB, ymmC); 5546 e->vpsravd(ymmA, ymmB, anyptr_gpC); 5547 e->vpsravd(zmmA, zmmB, zmmC); 5548 e->vpsravd(zmmA, zmmB, anyptr_gpC); 5549 e->vpsravq(xmmA, xmmB, xmmC); 5550 e->vpsravq(xmmA, xmmB, anyptr_gpC); 5551 e->vpsravq(ymmA, ymmB, ymmC); 5552 e->vpsravq(ymmA, ymmB, anyptr_gpC); 5553 e->vpsravq(zmmA, zmmB, zmmC); 5554 e->vpsravq(zmmA, zmmB, anyptr_gpC); 5555 e->vpsravw(xmmA, xmmB, xmmC); 5556 e->vpsravw(xmmA, xmmB, anyptr_gpC); 5557 e->vpsravw(ymmA, ymmB, ymmC); 5558 e->vpsravw(ymmA, ymmB, anyptr_gpC); 5559 e->vpsravw(zmmA, zmmB, zmmC); 5560 e->vpsravw(zmmA, zmmB, anyptr_gpC); 5561 e->vpsraw(xmmA, xmmB, xmmC); 5562 e->vpsraw(xmmA, xmmB, anyptr_gpC); 5563 e->vpsraw(xmmA, xmmB, 0); 5564 e->vpsraw(xmmA, anyptr_gpB, 0); 5565 e->vpsraw(ymmA, ymmB, xmmC); 5566 e->vpsraw(ymmA, ymmB, anyptr_gpC); 5567 e->vpsraw(ymmA, ymmB, 0); 5568 e->vpsraw(ymmA, anyptr_gpB, 0); 5569 e->vpsraw(zmmA, zmmB, xmmC); 5570 e->vpsraw(zmmA, zmmB, anyptr_gpC); 5571 e->vpsraw(zmmA, zmmB, 0); 5572 e->vpsraw(zmmA, anyptr_gpB, 0); 5573 e->vpsrld(xmmA, xmmB, xmmC); 5574 e->vpsrld(xmmA, xmmB, anyptr_gpC); 5575 e->vpsrld(xmmA, xmmB, 0); 5576 e->vpsrld(xmmA, anyptr_gpB, 0); 5577 e->vpsrld(ymmA, ymmB, xmmC); 5578 e->vpsrld(ymmA, ymmB, anyptr_gpC); 5579 e->vpsrld(ymmA, ymmB, 0); 5580 e->vpsrld(ymmA, anyptr_gpB, 0); 5581 e->vpsrld(zmmA, zmmB, xmmC); 5582 e->vpsrld(zmmA, zmmB, anyptr_gpC); 5583 e->vpsrld(zmmA, zmmB, 0); 5584 e->vpsrld(zmmA, anyptr_gpB, 0); 5585 e->vpsrldq(xmmA, xmmB, 0); 5586 e->vpsrldq(xmmA, anyptr_gpB, 0); 5587 e->vpsrldq(ymmA, ymmB, 0); 5588 e->vpsrldq(ymmA, anyptr_gpB, 0); 5589 e->vpsrldq(zmmA, zmmB, 0); 5590 e->vpsrldq(zmmA, anyptr_gpB, 0); 5591 e->vpsrlq(xmmA, xmmB, xmmC); 5592 e->vpsrlq(xmmA, xmmB, anyptr_gpC); 5593 e->vpsrlq(xmmA, xmmB, 0); 5594 e->vpsrlq(xmmA, anyptr_gpB, 0); 5595 e->vpsrlq(ymmA, ymmB, xmmC); 5596 e->vpsrlq(ymmA, ymmB, anyptr_gpC); 5597 e->vpsrlq(ymmA, ymmB, 0); 5598 e->vpsrlq(ymmA, anyptr_gpB, 0); 5599 e->vpsrlq(zmmA, zmmB, xmmC); 5600 e->vpsrlq(zmmA, zmmB, anyptr_gpC); 5601 e->vpsrlq(zmmA, zmmB, 0); 5602 e->vpsrlq(zmmA, anyptr_gpB, 0); 5603 e->vpsrlvd(xmmA, xmmB, xmmC); 5604 e->vpsrlvd(xmmA, xmmB, anyptr_gpC); 5605 e->vpsrlvd(ymmA, ymmB, ymmC); 5606 e->vpsrlvd(ymmA, ymmB, anyptr_gpC); 5607 e->vpsrlvd(zmmA, zmmB, zmmC); 5608 e->vpsrlvd(zmmA, zmmB, anyptr_gpC); 5609 e->vpsrlvq(xmmA, xmmB, xmmC); 5610 e->vpsrlvq(xmmA, xmmB, anyptr_gpC); 5611 e->vpsrlvq(ymmA, ymmB, ymmC); 5612 e->vpsrlvq(ymmA, ymmB, anyptr_gpC); 5613 e->vpsrlvq(zmmA, zmmB, zmmC); 5614 e->vpsrlvq(zmmA, zmmB, anyptr_gpC); 5615 e->vpsrlvw(xmmA, xmmB, xmmC); 5616 e->vpsrlvw(xmmA, xmmB, anyptr_gpC); 5617 e->vpsrlvw(ymmA, ymmB, ymmC); 5618 e->vpsrlvw(ymmA, ymmB, anyptr_gpC); 5619 e->vpsrlvw(zmmA, zmmB, zmmC); 5620 e->vpsrlvw(zmmA, zmmB, anyptr_gpC); 5621 e->vpsrlw(xmmA, xmmB, xmmC); 5622 e->vpsrlw(xmmA, xmmB, anyptr_gpC); 5623 e->vpsrlw(xmmA, xmmB, 0); 5624 e->vpsrlw(xmmA, anyptr_gpB, 0); 5625 e->vpsrlw(ymmA, ymmB, xmmC); 5626 e->vpsrlw(ymmA, ymmB, anyptr_gpC); 5627 e->vpsrlw(ymmA, ymmB, 0); 5628 e->vpsrlw(ymmA, anyptr_gpB, 0); 5629 e->vpsrlw(zmmA, zmmB, xmmC); 5630 e->vpsrlw(zmmA, zmmB, anyptr_gpC); 5631 e->vpsrlw(zmmA, zmmB, 0); 5632 e->vpsrlw(zmmA, anyptr_gpB, 0); 5633 e->vpsubb(xmmA, xmmB, xmmC); 5634 e->vpsubb(xmmA, xmmB, anyptr_gpC); 5635 e->vpsubb(ymmA, ymmB, ymmC); 5636 e->vpsubb(ymmA, ymmB, anyptr_gpC); 5637 e->vpsubb(zmmA, zmmB, zmmC); 5638 e->vpsubb(zmmA, zmmB, anyptr_gpC); 5639 e->vpsubd(xmmA, xmmB, xmmC); 5640 e->vpsubd(xmmA, xmmB, anyptr_gpC); 5641 e->vpsubd(ymmA, ymmB, ymmC); 5642 e->vpsubd(ymmA, ymmB, anyptr_gpC); 5643 e->vpsubd(zmmA, zmmB, zmmC); 5644 e->vpsubd(zmmA, zmmB, anyptr_gpC); 5645 e->vpsubq(xmmA, xmmB, xmmC); 5646 e->vpsubq(xmmA, xmmB, anyptr_gpC); 5647 e->vpsubq(ymmA, ymmB, ymmC); 5648 e->vpsubq(ymmA, ymmB, anyptr_gpC); 5649 e->vpsubq(zmmA, zmmB, zmmC); 5650 e->vpsubq(zmmA, zmmB, anyptr_gpC); 5651 e->vpsubsb(xmmA, xmmB, xmmC); 5652 e->vpsubsb(xmmA, xmmB, anyptr_gpC); 5653 e->vpsubsb(ymmA, ymmB, ymmC); 5654 e->vpsubsb(ymmA, ymmB, anyptr_gpC); 5655 e->vpsubsb(zmmA, zmmB, zmmC); 5656 e->vpsubsb(zmmA, zmmB, anyptr_gpC); 5657 e->vpsubsw(xmmA, xmmB, xmmC); 5658 e->vpsubsw(xmmA, xmmB, anyptr_gpC); 5659 e->vpsubsw(ymmA, ymmB, ymmC); 5660 e->vpsubsw(ymmA, ymmB, anyptr_gpC); 5661 e->vpsubsw(zmmA, zmmB, zmmC); 5662 e->vpsubsw(zmmA, zmmB, anyptr_gpC); 5663 e->vpsubusb(xmmA, xmmB, xmmC); 5664 e->vpsubusb(xmmA, xmmB, anyptr_gpC); 5665 e->vpsubusb(ymmA, ymmB, ymmC); 5666 e->vpsubusb(ymmA, ymmB, anyptr_gpC); 5667 e->vpsubusb(zmmA, zmmB, zmmC); 5668 e->vpsubusb(zmmA, zmmB, anyptr_gpC); 5669 e->vpsubusw(xmmA, xmmB, xmmC); 5670 e->vpsubusw(xmmA, xmmB, anyptr_gpC); 5671 e->vpsubusw(ymmA, ymmB, ymmC); 5672 e->vpsubusw(ymmA, ymmB, anyptr_gpC); 5673 e->vpsubusw(zmmA, zmmB, zmmC); 5674 e->vpsubusw(zmmA, zmmB, anyptr_gpC); 5675 e->vpsubw(xmmA, xmmB, xmmC); 5676 e->vpsubw(xmmA, xmmB, anyptr_gpC); 5677 e->vpsubw(ymmA, ymmB, ymmC); 5678 e->vpsubw(ymmA, ymmB, anyptr_gpC); 5679 e->vpsubw(zmmA, zmmB, zmmC); 5680 e->vpsubw(zmmA, zmmB, anyptr_gpC); 5681 e->vpternlogd(xmmA, xmmB, xmmC, 0); 5682 e->vpternlogd(xmmA, xmmB, anyptr_gpC, 0); 5683 e->vpternlogd(ymmA, ymmB, ymmC, 0); 5684 e->vpternlogd(ymmA, ymmB, anyptr_gpC, 0); 5685 e->vpternlogd(zmmA, zmmB, zmmC, 0); 5686 e->vpternlogd(zmmA, zmmB, anyptr_gpC, 0); 5687 e->vpternlogq(xmmA, xmmB, xmmC, 0); 5688 e->vpternlogq(xmmA, xmmB, anyptr_gpC, 0); 5689 e->vpternlogq(ymmA, ymmB, ymmC, 0); 5690 e->vpternlogq(ymmA, ymmB, anyptr_gpC, 0); 5691 e->vpternlogq(zmmA, zmmB, zmmC, 0); 5692 e->vpternlogq(zmmA, zmmB, anyptr_gpC, 0); 5693 e->vptestmb(kA, xmmB, xmmC); 5694 e->vptestmb(kA, xmmB, anyptr_gpC); 5695 e->vptestmb(kA, ymmB, ymmC); 5696 e->vptestmb(kA, ymmB, anyptr_gpC); 5697 e->vptestmb(kA, zmmB, zmmC); 5698 e->vptestmb(kA, zmmB, anyptr_gpC); 5699 e->vptestmd(kA, xmmB, xmmC); 5700 e->vptestmd(kA, xmmB, anyptr_gpC); 5701 e->vptestmd(kA, ymmB, ymmC); 5702 e->vptestmd(kA, ymmB, anyptr_gpC); 5703 e->vptestmd(kA, zmmB, zmmC); 5704 e->vptestmd(kA, zmmB, anyptr_gpC); 5705 e->vptestmq(kA, xmmB, xmmC); 5706 e->vptestmq(kA, xmmB, anyptr_gpC); 5707 e->vptestmq(kA, ymmB, ymmC); 5708 e->vptestmq(kA, ymmB, anyptr_gpC); 5709 e->vptestmq(kA, zmmB, zmmC); 5710 e->vptestmq(kA, zmmB, anyptr_gpC); 5711 e->vptestmw(kA, xmmB, xmmC); 5712 e->vptestmw(kA, xmmB, anyptr_gpC); 5713 e->vptestmw(kA, ymmB, ymmC); 5714 e->vptestmw(kA, ymmB, anyptr_gpC); 5715 e->vptestmw(kA, zmmB, zmmC); 5716 e->vptestmw(kA, zmmB, anyptr_gpC); 5717 e->vptestnmb(kA, xmmB, xmmC); 5718 e->vptestnmb(kA, xmmB, anyptr_gpC); 5719 e->vptestnmb(kA, ymmB, ymmC); 5720 e->vptestnmb(kA, ymmB, anyptr_gpC); 5721 e->vptestnmb(kA, zmmB, zmmC); 5722 e->vptestnmb(kA, zmmB, anyptr_gpC); 5723 e->vptestnmd(kA, xmmB, xmmC); 5724 e->vptestnmd(kA, xmmB, anyptr_gpC); 5725 e->vptestnmd(kA, ymmB, ymmC); 5726 e->vptestnmd(kA, ymmB, anyptr_gpC); 5727 e->vptestnmd(kA, zmmB, zmmC); 5728 e->vptestnmd(kA, zmmB, anyptr_gpC); 5729 e->vptestnmq(kA, xmmB, xmmC); 5730 e->vptestnmq(kA, xmmB, anyptr_gpC); 5731 e->vptestnmq(kA, ymmB, ymmC); 5732 e->vptestnmq(kA, ymmB, anyptr_gpC); 5733 e->vptestnmq(kA, zmmB, zmmC); 5734 e->vptestnmq(kA, zmmB, anyptr_gpC); 5735 e->vptestnmw(kA, xmmB, xmmC); 5736 e->vptestnmw(kA, xmmB, anyptr_gpC); 5737 e->vptestnmw(kA, ymmB, ymmC); 5738 e->vptestnmw(kA, ymmB, anyptr_gpC); 5739 e->vptestnmw(kA, zmmB, zmmC); 5740 e->vptestnmw(kA, zmmB, anyptr_gpC); 5741 e->vpunpckhbw(xmmA, xmmB, xmmC); 5742 e->vpunpckhbw(xmmA, xmmB, anyptr_gpC); 5743 e->vpunpckhbw(ymmA, ymmB, ymmC); 5744 e->vpunpckhbw(ymmA, ymmB, anyptr_gpC); 5745 e->vpunpckhbw(zmmA, zmmB, zmmC); 5746 e->vpunpckhbw(zmmA, zmmB, anyptr_gpC); 5747 e->vpunpckhdq(xmmA, xmmB, xmmC); 5748 e->vpunpckhdq(xmmA, xmmB, anyptr_gpC); 5749 e->vpunpckhdq(ymmA, ymmB, ymmC); 5750 e->vpunpckhdq(ymmA, ymmB, anyptr_gpC); 5751 e->vpunpckhdq(zmmA, zmmB, zmmC); 5752 e->vpunpckhdq(zmmA, zmmB, anyptr_gpC); 5753 e->vpunpckhqdq(xmmA, xmmB, xmmC); 5754 e->vpunpckhqdq(xmmA, xmmB, anyptr_gpC); 5755 e->vpunpckhqdq(ymmA, ymmB, ymmC); 5756 e->vpunpckhqdq(ymmA, ymmB, anyptr_gpC); 5757 e->vpunpckhqdq(zmmA, zmmB, zmmC); 5758 e->vpunpckhqdq(zmmA, zmmB, anyptr_gpC); 5759 e->vpunpckhwd(xmmA, xmmB, xmmC); 5760 e->vpunpckhwd(xmmA, xmmB, anyptr_gpC); 5761 e->vpunpckhwd(ymmA, ymmB, ymmC); 5762 e->vpunpckhwd(ymmA, ymmB, anyptr_gpC); 5763 e->vpunpckhwd(zmmA, zmmB, zmmC); 5764 e->vpunpckhwd(zmmA, zmmB, anyptr_gpC); 5765 e->vpunpcklbw(xmmA, xmmB, xmmC); 5766 e->vpunpcklbw(xmmA, xmmB, anyptr_gpC); 5767 e->vpunpcklbw(ymmA, ymmB, ymmC); 5768 e->vpunpcklbw(ymmA, ymmB, anyptr_gpC); 5769 e->vpunpcklbw(zmmA, zmmB, zmmC); 5770 e->vpunpcklbw(zmmA, zmmB, anyptr_gpC); 5771 e->vpunpckldq(xmmA, xmmB, xmmC); 5772 e->vpunpckldq(xmmA, xmmB, anyptr_gpC); 5773 e->vpunpckldq(ymmA, ymmB, ymmC); 5774 e->vpunpckldq(ymmA, ymmB, anyptr_gpC); 5775 e->vpunpckldq(zmmA, zmmB, zmmC); 5776 e->vpunpckldq(zmmA, zmmB, anyptr_gpC); 5777 e->vpunpcklqdq(xmmA, xmmB, xmmC); 5778 e->vpunpcklqdq(xmmA, xmmB, anyptr_gpC); 5779 e->vpunpcklqdq(ymmA, ymmB, ymmC); 5780 e->vpunpcklqdq(ymmA, ymmB, anyptr_gpC); 5781 e->vpunpcklqdq(zmmA, zmmB, zmmC); 5782 e->vpunpcklqdq(zmmA, zmmB, anyptr_gpC); 5783 e->vpunpcklwd(xmmA, xmmB, xmmC); 5784 e->vpunpcklwd(xmmA, xmmB, anyptr_gpC); 5785 e->vpunpcklwd(ymmA, ymmB, ymmC); 5786 e->vpunpcklwd(ymmA, ymmB, anyptr_gpC); 5787 e->vpunpcklwd(zmmA, zmmB, zmmC); 5788 e->vpunpcklwd(zmmA, zmmB, anyptr_gpC); 5789 e->vpxord(xmmA, xmmB, xmmC); 5790 e->vpxord(xmmA, xmmB, anyptr_gpC); 5791 e->vpxord(ymmA, ymmB, ymmC); 5792 e->vpxord(ymmA, ymmB, anyptr_gpC); 5793 e->vpxord(zmmA, zmmB, zmmC); 5794 e->vpxord(zmmA, zmmB, anyptr_gpC); 5795 e->vpxorq(xmmA, xmmB, xmmC); 5796 e->vpxorq(xmmA, xmmB, anyptr_gpC); 5797 e->vpxorq(ymmA, ymmB, ymmC); 5798 e->vpxorq(ymmA, ymmB, anyptr_gpC); 5799 e->vpxorq(zmmA, zmmB, zmmC); 5800 e->vpxorq(zmmA, zmmB, anyptr_gpC); 5801 e->vrangepd(xmmA, xmmB, xmmC, 0); 5802 e->vrangepd(xmmA, xmmB, anyptr_gpC, 0); 5803 e->vrangepd(ymmA, ymmB, ymmC, 0); 5804 e->vrangepd(ymmA, ymmB, anyptr_gpC, 0); 5805 e->vrangepd(zmmA, zmmB, zmmC, 0); 5806 e->vrangepd(zmmA, zmmB, anyptr_gpC, 0); 5807 e->vrangeps(xmmA, xmmB, xmmC, 0); 5808 e->vrangeps(xmmA, xmmB, anyptr_gpC, 0); 5809 e->vrangeps(ymmA, ymmB, ymmC, 0); 5810 e->vrangeps(ymmA, ymmB, anyptr_gpC, 0); 5811 e->vrangeps(zmmA, zmmB, zmmC, 0); 5812 e->vrangeps(zmmA, zmmB, anyptr_gpC, 0); 5813 e->vrangesd(xmmA, xmmB, xmmC, 0); 5814 e->vrangesd(xmmA, xmmB, anyptr_gpC, 0); 5815 e->vrangess(xmmA, xmmB, xmmC, 0); 5816 e->vrangess(xmmA, xmmB, anyptr_gpC, 0); 5817 e->vrcp14pd(xmmA, xmmB); 5818 e->vrcp14pd(xmmA, anyptr_gpB); 5819 e->vrcp14pd(ymmA, ymmB); 5820 e->vrcp14pd(ymmA, anyptr_gpB); 5821 e->vrcp14pd(zmmA, zmmB); 5822 e->vrcp14pd(zmmA, anyptr_gpB); 5823 e->vrcp14ps(xmmA, xmmB); 5824 e->vrcp14ps(xmmA, anyptr_gpB); 5825 e->vrcp14ps(ymmA, ymmB); 5826 e->vrcp14ps(ymmA, anyptr_gpB); 5827 e->vrcp14ps(zmmA, zmmB); 5828 e->vrcp14ps(zmmA, anyptr_gpB); 5829 e->vrcp14sd(xmmA, xmmB, xmmC); 5830 e->vrcp14sd(xmmA, xmmB, anyptr_gpC); 5831 e->vrcp14ss(xmmA, xmmB, xmmC); 5832 e->vrcp14ss(xmmA, xmmB, anyptr_gpC); 5833 e->vrcp28pd(zmmA, zmmB); 5834 e->vrcp28pd(zmmA, anyptr_gpB); 5835 e->vrcp28ps(zmmA, zmmB); 5836 e->vrcp28ps(zmmA, anyptr_gpB); 5837 e->vrcp28sd(xmmA, xmmB, xmmC); 5838 e->vrcp28sd(xmmA, xmmB, anyptr_gpC); 5839 e->vrcp28ss(xmmA, xmmB, xmmC); 5840 e->vrcp28ss(xmmA, xmmB, anyptr_gpC); 5841 e->vreducepd(xmmA, xmmB, 0); 5842 e->vreducepd(xmmA, anyptr_gpB, 0); 5843 e->vreducepd(ymmA, ymmB, 0); 5844 e->vreducepd(ymmA, anyptr_gpB, 0); 5845 e->vreducepd(zmmA, zmmB, 0); 5846 e->vreducepd(zmmA, anyptr_gpB, 0); 5847 e->vreduceps(xmmA, xmmB, 0); 5848 e->vreduceps(xmmA, anyptr_gpB, 0); 5849 e->vreduceps(ymmA, ymmB, 0); 5850 e->vreduceps(ymmA, anyptr_gpB, 0); 5851 e->vreduceps(zmmA, zmmB, 0); 5852 e->vreduceps(zmmA, anyptr_gpB, 0); 5853 e->vreducesd(xmmA, xmmB, xmmC, 0); 5854 e->vreducesd(xmmA, xmmB, anyptr_gpC, 0); 5855 e->vreducess(xmmA, xmmB, xmmC, 0); 5856 e->vreducess(xmmA, xmmB, anyptr_gpC, 0); 5857 e->vrndscalepd(xmmA, xmmB, 0); 5858 e->vrndscalepd(xmmA, anyptr_gpB, 0); 5859 e->vrndscalepd(ymmA, ymmB, 0); 5860 e->vrndscalepd(ymmA, anyptr_gpB, 0); 5861 e->vrndscalepd(zmmA, zmmB, 0); 5862 e->vrndscalepd(zmmA, anyptr_gpB, 0); 5863 e->vrndscaleps(xmmA, xmmB, 0); 5864 e->vrndscaleps(xmmA, anyptr_gpB, 0); 5865 e->vrndscaleps(ymmA, ymmB, 0); 5866 e->vrndscaleps(ymmA, anyptr_gpB, 0); 5867 e->vrndscaleps(zmmA, zmmB, 0); 5868 e->vrndscaleps(zmmA, anyptr_gpB, 0); 5869 e->vrndscalesd(xmmA, xmmB, xmmC, 0); 5870 e->vrndscalesd(xmmA, xmmB, anyptr_gpC, 0); 5871 e->vrndscaless(xmmA, xmmB, xmmC, 0); 5872 e->vrndscaless(xmmA, xmmB, anyptr_gpC, 0); 5873 e->vrsqrt14pd(xmmA, xmmB); 5874 e->vrsqrt14pd(xmmA, anyptr_gpB); 5875 e->vrsqrt14pd(ymmA, ymmB); 5876 e->vrsqrt14pd(ymmA, anyptr_gpB); 5877 e->vrsqrt14pd(zmmA, zmmB); 5878 e->vrsqrt14pd(zmmA, anyptr_gpB); 5879 e->vrsqrt14ps(xmmA, xmmB); 5880 e->vrsqrt14ps(xmmA, anyptr_gpB); 5881 e->vrsqrt14ps(ymmA, ymmB); 5882 e->vrsqrt14ps(ymmA, anyptr_gpB); 5883 e->vrsqrt14ps(zmmA, zmmB); 5884 e->vrsqrt14ps(zmmA, anyptr_gpB); 5885 e->vrsqrt14sd(xmmA, xmmB, xmmC); 5886 e->vrsqrt14sd(xmmA, xmmB, anyptr_gpC); 5887 e->vrsqrt14ss(xmmA, xmmB, xmmC); 5888 e->vrsqrt14ss(xmmA, xmmB, anyptr_gpC); 5889 e->vrsqrt28pd(zmmA, zmmB); 5890 e->vrsqrt28pd(zmmA, anyptr_gpB); 5891 e->vrsqrt28ps(zmmA, zmmB); 5892 e->vrsqrt28ps(zmmA, anyptr_gpB); 5893 e->vrsqrt28sd(xmmA, xmmB, xmmC); 5894 e->vrsqrt28sd(xmmA, xmmB, anyptr_gpC); 5895 e->vrsqrt28ss(xmmA, xmmB, xmmC); 5896 e->vrsqrt28ss(xmmA, xmmB, anyptr_gpC); 5897 e->vscalefpd(xmmA, xmmB, xmmC); 5898 e->vscalefpd(xmmA, xmmB, anyptr_gpC); 5899 e->vscalefpd(ymmA, ymmB, ymmC); 5900 e->vscalefpd(ymmA, ymmB, anyptr_gpC); 5901 e->vscalefpd(zmmA, zmmB, zmmC); 5902 e->vscalefpd(zmmA, zmmB, anyptr_gpC); 5903 e->vscalefps(xmmA, xmmB, xmmC); 5904 e->vscalefps(xmmA, xmmB, anyptr_gpC); 5905 e->vscalefps(ymmA, ymmB, ymmC); 5906 e->vscalefps(ymmA, ymmB, anyptr_gpC); 5907 e->vscalefps(zmmA, zmmB, zmmC); 5908 e->vscalefps(zmmA, zmmB, anyptr_gpC); 5909 e->vscalefsd(xmmA, xmmB, xmmC); 5910 e->vscalefsd(xmmA, xmmB, anyptr_gpC); 5911 e->vscalefss(xmmA, xmmB, xmmC); 5912 e->vscalefss(xmmA, xmmB, anyptr_gpC); 5913 e->vscatterdpd(vx_ptr, xmmB); 5914 e->vscatterdpd(vx_ptr, ymmB); 5915 e->vscatterdpd(vy_ptr, zmmB); 5916 e->vscatterdps(vx_ptr, xmmB); 5917 e->vscatterdps(vy_ptr, ymmB); 5918 e->vscatterdps(vz_ptr, zmmB); 5919 e->vscatterpf0dpd(vy_ptr); 5920 e->vscatterpf0dps(vz_ptr); 5921 e->vscatterpf0qpd(vz_ptr); 5922 e->vscatterpf0qps(vz_ptr); 5923 e->vscatterpf1dpd(vy_ptr); 5924 e->vscatterpf1dps(vz_ptr); 5925 e->vscatterpf1qpd(vz_ptr); 5926 e->vscatterpf1qps(vz_ptr); 5927 e->vscatterqpd(vx_ptr, xmmB); 5928 e->vscatterqpd(vy_ptr, ymmB); 5929 e->vscatterqpd(vz_ptr, zmmB); 5930 e->vscatterqps(vx_ptr, xmmB); 5931 e->vscatterqps(vy_ptr, xmmB); 5932 e->vscatterqps(vz_ptr, ymmB); 5933 e->vshuff32x4(ymmA, ymmB, ymmC, 0); 5934 e->vshuff32x4(ymmA, ymmB, anyptr_gpC, 0); 5935 e->vshuff32x4(zmmA, zmmB, zmmC, 0); 5936 e->vshuff32x4(zmmA, zmmB, anyptr_gpC, 0); 5937 e->vshuff64x2(ymmA, ymmB, ymmC, 0); 5938 e->vshuff64x2(ymmA, ymmB, anyptr_gpC, 0); 5939 e->vshuff64x2(zmmA, zmmB, zmmC, 0); 5940 e->vshuff64x2(zmmA, zmmB, anyptr_gpC, 0); 5941 e->vshufi32x4(ymmA, ymmB, ymmC, 0); 5942 e->vshufi32x4(ymmA, ymmB, anyptr_gpC, 0); 5943 e->vshufi32x4(zmmA, zmmB, zmmC, 0); 5944 e->vshufi32x4(zmmA, zmmB, anyptr_gpC, 0); 5945 e->vshufi64x2(ymmA, ymmB, ymmC, 0); 5946 e->vshufi64x2(ymmA, ymmB, anyptr_gpC, 0); 5947 e->vshufi64x2(zmmA, zmmB, zmmC, 0); 5948 e->vshufi64x2(zmmA, zmmB, anyptr_gpC, 0); 5949 e->vshufpd(xmmA, xmmB, xmmC, 0); 5950 e->vshufpd(xmmA, xmmB, anyptr_gpC, 0); 5951 e->vshufpd(ymmA, ymmB, ymmC, 0); 5952 e->vshufpd(ymmA, ymmB, anyptr_gpC, 0); 5953 e->vshufpd(zmmA, zmmB, zmmC, 0); 5954 e->vshufpd(zmmA, zmmB, anyptr_gpC, 0); 5955 e->vshufps(xmmA, xmmB, xmmC, 0); 5956 e->vshufps(xmmA, xmmB, anyptr_gpC, 0); 5957 e->vshufps(ymmA, ymmB, ymmC, 0); 5958 e->vshufps(ymmA, ymmB, anyptr_gpC, 0); 5959 e->vshufps(zmmA, zmmB, zmmC, 0); 5960 e->vshufps(zmmA, zmmB, anyptr_gpC, 0); 5961 e->vsqrtpd(xmmA, xmmB); 5962 e->vsqrtpd(xmmA, anyptr_gpB); 5963 e->vsqrtpd(ymmA, ymmB); 5964 e->vsqrtpd(ymmA, anyptr_gpB); 5965 e->vsqrtpd(zmmA, zmmB); 5966 e->vsqrtpd(zmmA, anyptr_gpB); 5967 e->vsqrtps(xmmA, xmmB); 5968 e->vsqrtps(xmmA, anyptr_gpB); 5969 e->vsqrtps(ymmA, ymmB); 5970 e->vsqrtps(ymmA, anyptr_gpB); 5971 e->vsqrtps(zmmA, zmmB); 5972 e->vsqrtps(zmmA, anyptr_gpB); 5973 e->vsqrtsd(xmmA, xmmB, xmmC); 5974 e->vsqrtsd(xmmA, xmmB, anyptr_gpC); 5975 e->vsqrtss(xmmA, xmmB, xmmC); 5976 e->vsqrtss(xmmA, xmmB, anyptr_gpC); 5977 e->vsubpd(xmmA, xmmB, xmmC); 5978 e->vsubpd(xmmA, xmmB, anyptr_gpC); 5979 e->vsubpd(ymmA, ymmB, ymmC); 5980 e->vsubpd(ymmA, ymmB, anyptr_gpC); 5981 e->vsubpd(zmmA, zmmB, zmmC); 5982 e->vsubpd(zmmA, zmmB, anyptr_gpC); 5983 e->vsubps(xmmA, xmmB, xmmC); 5984 e->vsubps(xmmA, xmmB, anyptr_gpC); 5985 e->vsubps(ymmA, ymmB, ymmC); 5986 e->vsubps(ymmA, ymmB, anyptr_gpC); 5987 e->vsubps(zmmA, zmmB, zmmC); 5988 e->vsubps(zmmA, zmmB, anyptr_gpC); 5989 e->vsubsd(xmmA, xmmB, xmmC); 5990 e->vsubsd(xmmA, xmmB, anyptr_gpC); 5991 e->vsubss(xmmA, xmmB, xmmC); 5992 e->vsubss(xmmA, xmmB, anyptr_gpC); 5993 e->vucomisd(xmmA, xmmB); 5994 e->vucomisd(xmmA, anyptr_gpB); 5995 e->vucomiss(xmmA, xmmB); 5996 e->vucomiss(xmmA, anyptr_gpB); 5997 e->vunpckhpd(xmmA, xmmB, xmmC); 5998 e->vunpckhpd(xmmA, xmmB, anyptr_gpC); 5999 e->vunpckhpd(ymmA, ymmB, ymmC); 6000 e->vunpckhpd(ymmA, ymmB, anyptr_gpC); 6001 e->vunpckhpd(zmmA, zmmB, zmmC); 6002 e->vunpckhpd(zmmA, zmmB, anyptr_gpC); 6003 e->vunpckhps(xmmA, xmmB, xmmC); 6004 e->vunpckhps(xmmA, xmmB, anyptr_gpC); 6005 e->vunpckhps(ymmA, ymmB, ymmC); 6006 e->vunpckhps(ymmA, ymmB, anyptr_gpC); 6007 e->vunpckhps(zmmA, zmmB, zmmC); 6008 e->vunpckhps(zmmA, zmmB, anyptr_gpC); 6009 e->vunpcklpd(xmmA, xmmB, xmmC); 6010 e->vunpcklpd(xmmA, xmmB, anyptr_gpC); 6011 e->vunpcklpd(ymmA, ymmB, ymmC); 6012 e->vunpcklpd(ymmA, ymmB, anyptr_gpC); 6013 e->vunpcklpd(zmmA, zmmB, zmmC); 6014 e->vunpcklpd(zmmA, zmmB, anyptr_gpC); 6015 e->vunpcklps(xmmA, xmmB, xmmC); 6016 e->vunpcklps(xmmA, xmmB, anyptr_gpC); 6017 e->vunpcklps(ymmA, ymmB, ymmC); 6018 e->vunpcklps(ymmA, ymmB, anyptr_gpC); 6019 e->vunpcklps(zmmA, zmmB, zmmC); 6020 e->vunpcklps(zmmA, zmmB, anyptr_gpC); 6021 e->vxorpd(xmmA, xmmB, xmmC); 6022 e->vxorpd(xmmA, xmmB, anyptr_gpC); 6023 e->vxorpd(ymmA, ymmB, ymmC); 6024 e->vxorpd(ymmA, ymmB, anyptr_gpC); 6025 e->vxorpd(zmmA, zmmB, zmmC); 6026 e->vxorpd(zmmA, zmmB, anyptr_gpC); 6027 e->vxorps(xmmA, xmmB, xmmC); 6028 e->vxorps(xmmA, xmmB, anyptr_gpC); 6029 e->vxorps(ymmA, ymmB, ymmC); 6030 e->vxorps(ymmA, ymmB, anyptr_gpC); 6031 e->vxorps(zmmA, zmmB, zmmC); 6032 e->vxorps(zmmA, zmmB, anyptr_gpC); 6033 6034 // Mark the end. 6035 e->nop(); 6036 e->nop(); 6037 e->nop(); 6038 e->nop(); 6039 } 6040 6041 } // {asmtest} 6042 6043 #endif // _ASMJIT_TEST_OPCODE_H 6044