1// Code generated by command: avogen -output zinstructions.go build. DO NOT EDIT. 2 3package build 4 5import ( 6 "github.com/mmcloughlin/avo/operand" 7 "github.com/mmcloughlin/avo/x86" 8) 9 10// ADCB: Add with Carry. 11// 12// Forms: 13// 14// ADCB imm8 al 15// ADCB imm8 r8 16// ADCB r8 r8 17// ADCB m8 r8 18// ADCB imm8 m8 19// ADCB r8 m8 20// Construct and append a ADCB instruction to the active function. 21func (c *Context) ADCB(imr, amr operand.Op) { 22 if inst, err := x86.ADCB(imr, amr); err == nil { 23 c.Instruction(inst) 24 } else { 25 c.adderror(err) 26 } 27} 28 29// ADCB: Add with Carry. 30// 31// Forms: 32// 33// ADCB imm8 al 34// ADCB imm8 r8 35// ADCB r8 r8 36// ADCB m8 r8 37// ADCB imm8 m8 38// ADCB r8 m8 39// Construct and append a ADCB instruction to the active function. 40// Operates on the global context. 41func ADCB(imr, amr operand.Op) { ctx.ADCB(imr, amr) } 42 43// ADCL: Add with Carry. 44// 45// Forms: 46// 47// ADCL imm32 eax 48// ADCL imm8 r32 49// ADCL imm32 r32 50// ADCL r32 r32 51// ADCL m32 r32 52// ADCL imm8 m32 53// ADCL imm32 m32 54// ADCL r32 m32 55// Construct and append a ADCL instruction to the active function. 56func (c *Context) ADCL(imr, emr operand.Op) { 57 if inst, err := x86.ADCL(imr, emr); err == nil { 58 c.Instruction(inst) 59 } else { 60 c.adderror(err) 61 } 62} 63 64// ADCL: Add with Carry. 65// 66// Forms: 67// 68// ADCL imm32 eax 69// ADCL imm8 r32 70// ADCL imm32 r32 71// ADCL r32 r32 72// ADCL m32 r32 73// ADCL imm8 m32 74// ADCL imm32 m32 75// ADCL r32 m32 76// Construct and append a ADCL instruction to the active function. 77// Operates on the global context. 78func ADCL(imr, emr operand.Op) { ctx.ADCL(imr, emr) } 79 80// ADCQ: Add with Carry. 81// 82// Forms: 83// 84// ADCQ imm32 rax 85// ADCQ imm8 r64 86// ADCQ imm32 r64 87// ADCQ r64 r64 88// ADCQ m64 r64 89// ADCQ imm8 m64 90// ADCQ imm32 m64 91// ADCQ r64 m64 92// Construct and append a ADCQ instruction to the active function. 93func (c *Context) ADCQ(imr, mr operand.Op) { 94 if inst, err := x86.ADCQ(imr, mr); err == nil { 95 c.Instruction(inst) 96 } else { 97 c.adderror(err) 98 } 99} 100 101// ADCQ: Add with Carry. 102// 103// Forms: 104// 105// ADCQ imm32 rax 106// ADCQ imm8 r64 107// ADCQ imm32 r64 108// ADCQ r64 r64 109// ADCQ m64 r64 110// ADCQ imm8 m64 111// ADCQ imm32 m64 112// ADCQ r64 m64 113// Construct and append a ADCQ instruction to the active function. 114// Operates on the global context. 115func ADCQ(imr, mr operand.Op) { ctx.ADCQ(imr, mr) } 116 117// ADCW: Add with Carry. 118// 119// Forms: 120// 121// ADCW imm16 ax 122// ADCW imm8 r16 123// ADCW imm16 r16 124// ADCW r16 r16 125// ADCW m16 r16 126// ADCW imm8 m16 127// ADCW imm16 m16 128// ADCW r16 m16 129// Construct and append a ADCW instruction to the active function. 130func (c *Context) ADCW(imr, amr operand.Op) { 131 if inst, err := x86.ADCW(imr, amr); err == nil { 132 c.Instruction(inst) 133 } else { 134 c.adderror(err) 135 } 136} 137 138// ADCW: Add with Carry. 139// 140// Forms: 141// 142// ADCW imm16 ax 143// ADCW imm8 r16 144// ADCW imm16 r16 145// ADCW r16 r16 146// ADCW m16 r16 147// ADCW imm8 m16 148// ADCW imm16 m16 149// ADCW r16 m16 150// Construct and append a ADCW instruction to the active function. 151// Operates on the global context. 152func ADCW(imr, amr operand.Op) { ctx.ADCW(imr, amr) } 153 154// ADCXL: Unsigned Integer Addition of Two Operands with Carry Flag. 155// 156// Forms: 157// 158// ADCXL r32 r32 159// ADCXL m32 r32 160// Construct and append a ADCXL instruction to the active function. 161func (c *Context) ADCXL(mr, r operand.Op) { 162 if inst, err := x86.ADCXL(mr, r); err == nil { 163 c.Instruction(inst) 164 } else { 165 c.adderror(err) 166 } 167} 168 169// ADCXL: Unsigned Integer Addition of Two Operands with Carry Flag. 170// 171// Forms: 172// 173// ADCXL r32 r32 174// ADCXL m32 r32 175// Construct and append a ADCXL instruction to the active function. 176// Operates on the global context. 177func ADCXL(mr, r operand.Op) { ctx.ADCXL(mr, r) } 178 179// ADCXQ: Unsigned Integer Addition of Two Operands with Carry Flag. 180// 181// Forms: 182// 183// ADCXQ r64 r64 184// ADCXQ m64 r64 185// Construct and append a ADCXQ instruction to the active function. 186func (c *Context) ADCXQ(mr, r operand.Op) { 187 if inst, err := x86.ADCXQ(mr, r); err == nil { 188 c.Instruction(inst) 189 } else { 190 c.adderror(err) 191 } 192} 193 194// ADCXQ: Unsigned Integer Addition of Two Operands with Carry Flag. 195// 196// Forms: 197// 198// ADCXQ r64 r64 199// ADCXQ m64 r64 200// Construct and append a ADCXQ instruction to the active function. 201// Operates on the global context. 202func ADCXQ(mr, r operand.Op) { ctx.ADCXQ(mr, r) } 203 204// ADDB: Add. 205// 206// Forms: 207// 208// ADDB imm8 al 209// ADDB imm8 r8 210// ADDB r8 r8 211// ADDB m8 r8 212// ADDB imm8 m8 213// ADDB r8 m8 214// Construct and append a ADDB instruction to the active function. 215func (c *Context) ADDB(imr, amr operand.Op) { 216 if inst, err := x86.ADDB(imr, amr); err == nil { 217 c.Instruction(inst) 218 } else { 219 c.adderror(err) 220 } 221} 222 223// ADDB: Add. 224// 225// Forms: 226// 227// ADDB imm8 al 228// ADDB imm8 r8 229// ADDB r8 r8 230// ADDB m8 r8 231// ADDB imm8 m8 232// ADDB r8 m8 233// Construct and append a ADDB instruction to the active function. 234// Operates on the global context. 235func ADDB(imr, amr operand.Op) { ctx.ADDB(imr, amr) } 236 237// ADDL: Add. 238// 239// Forms: 240// 241// ADDL imm32 eax 242// ADDL imm8 r32 243// ADDL imm32 r32 244// ADDL r32 r32 245// ADDL m32 r32 246// ADDL imm8 m32 247// ADDL imm32 m32 248// ADDL r32 m32 249// Construct and append a ADDL instruction to the active function. 250func (c *Context) ADDL(imr, emr operand.Op) { 251 if inst, err := x86.ADDL(imr, emr); err == nil { 252 c.Instruction(inst) 253 } else { 254 c.adderror(err) 255 } 256} 257 258// ADDL: Add. 259// 260// Forms: 261// 262// ADDL imm32 eax 263// ADDL imm8 r32 264// ADDL imm32 r32 265// ADDL r32 r32 266// ADDL m32 r32 267// ADDL imm8 m32 268// ADDL imm32 m32 269// ADDL r32 m32 270// Construct and append a ADDL instruction to the active function. 271// Operates on the global context. 272func ADDL(imr, emr operand.Op) { ctx.ADDL(imr, emr) } 273 274// ADDPD: Add Packed Double-Precision Floating-Point Values. 275// 276// Forms: 277// 278// ADDPD xmm xmm 279// ADDPD m128 xmm 280// Construct and append a ADDPD instruction to the active function. 281func (c *Context) ADDPD(mx, x operand.Op) { 282 if inst, err := x86.ADDPD(mx, x); err == nil { 283 c.Instruction(inst) 284 } else { 285 c.adderror(err) 286 } 287} 288 289// ADDPD: Add Packed Double-Precision Floating-Point Values. 290// 291// Forms: 292// 293// ADDPD xmm xmm 294// ADDPD m128 xmm 295// Construct and append a ADDPD instruction to the active function. 296// Operates on the global context. 297func ADDPD(mx, x operand.Op) { ctx.ADDPD(mx, x) } 298 299// ADDPS: Add Packed Single-Precision Floating-Point Values. 300// 301// Forms: 302// 303// ADDPS xmm xmm 304// ADDPS m128 xmm 305// Construct and append a ADDPS instruction to the active function. 306func (c *Context) ADDPS(mx, x operand.Op) { 307 if inst, err := x86.ADDPS(mx, x); err == nil { 308 c.Instruction(inst) 309 } else { 310 c.adderror(err) 311 } 312} 313 314// ADDPS: Add Packed Single-Precision Floating-Point Values. 315// 316// Forms: 317// 318// ADDPS xmm xmm 319// ADDPS m128 xmm 320// Construct and append a ADDPS instruction to the active function. 321// Operates on the global context. 322func ADDPS(mx, x operand.Op) { ctx.ADDPS(mx, x) } 323 324// ADDQ: Add. 325// 326// Forms: 327// 328// ADDQ imm32 rax 329// ADDQ imm8 r64 330// ADDQ imm32 r64 331// ADDQ r64 r64 332// ADDQ m64 r64 333// ADDQ imm8 m64 334// ADDQ imm32 m64 335// ADDQ r64 m64 336// Construct and append a ADDQ instruction to the active function. 337func (c *Context) ADDQ(imr, mr operand.Op) { 338 if inst, err := x86.ADDQ(imr, mr); err == nil { 339 c.Instruction(inst) 340 } else { 341 c.adderror(err) 342 } 343} 344 345// ADDQ: Add. 346// 347// Forms: 348// 349// ADDQ imm32 rax 350// ADDQ imm8 r64 351// ADDQ imm32 r64 352// ADDQ r64 r64 353// ADDQ m64 r64 354// ADDQ imm8 m64 355// ADDQ imm32 m64 356// ADDQ r64 m64 357// Construct and append a ADDQ instruction to the active function. 358// Operates on the global context. 359func ADDQ(imr, mr operand.Op) { ctx.ADDQ(imr, mr) } 360 361// ADDSD: Add Scalar Double-Precision Floating-Point Values. 362// 363// Forms: 364// 365// ADDSD xmm xmm 366// ADDSD m64 xmm 367// Construct and append a ADDSD instruction to the active function. 368func (c *Context) ADDSD(mx, x operand.Op) { 369 if inst, err := x86.ADDSD(mx, x); err == nil { 370 c.Instruction(inst) 371 } else { 372 c.adderror(err) 373 } 374} 375 376// ADDSD: Add Scalar Double-Precision Floating-Point Values. 377// 378// Forms: 379// 380// ADDSD xmm xmm 381// ADDSD m64 xmm 382// Construct and append a ADDSD instruction to the active function. 383// Operates on the global context. 384func ADDSD(mx, x operand.Op) { ctx.ADDSD(mx, x) } 385 386// ADDSS: Add Scalar Single-Precision Floating-Point Values. 387// 388// Forms: 389// 390// ADDSS xmm xmm 391// ADDSS m32 xmm 392// Construct and append a ADDSS instruction to the active function. 393func (c *Context) ADDSS(mx, x operand.Op) { 394 if inst, err := x86.ADDSS(mx, x); err == nil { 395 c.Instruction(inst) 396 } else { 397 c.adderror(err) 398 } 399} 400 401// ADDSS: Add Scalar Single-Precision Floating-Point Values. 402// 403// Forms: 404// 405// ADDSS xmm xmm 406// ADDSS m32 xmm 407// Construct and append a ADDSS instruction to the active function. 408// Operates on the global context. 409func ADDSS(mx, x operand.Op) { ctx.ADDSS(mx, x) } 410 411// ADDSUBPD: Packed Double-FP Add/Subtract. 412// 413// Forms: 414// 415// ADDSUBPD xmm xmm 416// ADDSUBPD m128 xmm 417// Construct and append a ADDSUBPD instruction to the active function. 418func (c *Context) ADDSUBPD(mx, x operand.Op) { 419 if inst, err := x86.ADDSUBPD(mx, x); err == nil { 420 c.Instruction(inst) 421 } else { 422 c.adderror(err) 423 } 424} 425 426// ADDSUBPD: Packed Double-FP Add/Subtract. 427// 428// Forms: 429// 430// ADDSUBPD xmm xmm 431// ADDSUBPD m128 xmm 432// Construct and append a ADDSUBPD instruction to the active function. 433// Operates on the global context. 434func ADDSUBPD(mx, x operand.Op) { ctx.ADDSUBPD(mx, x) } 435 436// ADDSUBPS: Packed Single-FP Add/Subtract. 437// 438// Forms: 439// 440// ADDSUBPS xmm xmm 441// ADDSUBPS m128 xmm 442// Construct and append a ADDSUBPS instruction to the active function. 443func (c *Context) ADDSUBPS(mx, x operand.Op) { 444 if inst, err := x86.ADDSUBPS(mx, x); err == nil { 445 c.Instruction(inst) 446 } else { 447 c.adderror(err) 448 } 449} 450 451// ADDSUBPS: Packed Single-FP Add/Subtract. 452// 453// Forms: 454// 455// ADDSUBPS xmm xmm 456// ADDSUBPS m128 xmm 457// Construct and append a ADDSUBPS instruction to the active function. 458// Operates on the global context. 459func ADDSUBPS(mx, x operand.Op) { ctx.ADDSUBPS(mx, x) } 460 461// ADDW: Add. 462// 463// Forms: 464// 465// ADDW imm16 ax 466// ADDW imm8 r16 467// ADDW imm16 r16 468// ADDW r16 r16 469// ADDW m16 r16 470// ADDW imm8 m16 471// ADDW imm16 m16 472// ADDW r16 m16 473// Construct and append a ADDW instruction to the active function. 474func (c *Context) ADDW(imr, amr operand.Op) { 475 if inst, err := x86.ADDW(imr, amr); err == nil { 476 c.Instruction(inst) 477 } else { 478 c.adderror(err) 479 } 480} 481 482// ADDW: Add. 483// 484// Forms: 485// 486// ADDW imm16 ax 487// ADDW imm8 r16 488// ADDW imm16 r16 489// ADDW r16 r16 490// ADDW m16 r16 491// ADDW imm8 m16 492// ADDW imm16 m16 493// ADDW r16 m16 494// Construct and append a ADDW instruction to the active function. 495// Operates on the global context. 496func ADDW(imr, amr operand.Op) { ctx.ADDW(imr, amr) } 497 498// ADOXL: Unsigned Integer Addition of Two Operands with Overflow Flag. 499// 500// Forms: 501// 502// ADOXL r32 r32 503// ADOXL m32 r32 504// Construct and append a ADOXL instruction to the active function. 505func (c *Context) ADOXL(mr, r operand.Op) { 506 if inst, err := x86.ADOXL(mr, r); err == nil { 507 c.Instruction(inst) 508 } else { 509 c.adderror(err) 510 } 511} 512 513// ADOXL: Unsigned Integer Addition of Two Operands with Overflow Flag. 514// 515// Forms: 516// 517// ADOXL r32 r32 518// ADOXL m32 r32 519// Construct and append a ADOXL instruction to the active function. 520// Operates on the global context. 521func ADOXL(mr, r operand.Op) { ctx.ADOXL(mr, r) } 522 523// ADOXQ: Unsigned Integer Addition of Two Operands with Overflow Flag. 524// 525// Forms: 526// 527// ADOXQ r64 r64 528// ADOXQ m64 r64 529// Construct and append a ADOXQ instruction to the active function. 530func (c *Context) ADOXQ(mr, r operand.Op) { 531 if inst, err := x86.ADOXQ(mr, r); err == nil { 532 c.Instruction(inst) 533 } else { 534 c.adderror(err) 535 } 536} 537 538// ADOXQ: Unsigned Integer Addition of Two Operands with Overflow Flag. 539// 540// Forms: 541// 542// ADOXQ r64 r64 543// ADOXQ m64 r64 544// Construct and append a ADOXQ instruction to the active function. 545// Operates on the global context. 546func ADOXQ(mr, r operand.Op) { ctx.ADOXQ(mr, r) } 547 548// AESDEC: Perform One Round of an AES Decryption Flow. 549// 550// Forms: 551// 552// AESDEC xmm xmm 553// AESDEC m128 xmm 554// Construct and append a AESDEC instruction to the active function. 555func (c *Context) AESDEC(mx, x operand.Op) { 556 if inst, err := x86.AESDEC(mx, x); err == nil { 557 c.Instruction(inst) 558 } else { 559 c.adderror(err) 560 } 561} 562 563// AESDEC: Perform One Round of an AES Decryption Flow. 564// 565// Forms: 566// 567// AESDEC xmm xmm 568// AESDEC m128 xmm 569// Construct and append a AESDEC instruction to the active function. 570// Operates on the global context. 571func AESDEC(mx, x operand.Op) { ctx.AESDEC(mx, x) } 572 573// AESDECLAST: Perform Last Round of an AES Decryption Flow. 574// 575// Forms: 576// 577// AESDECLAST xmm xmm 578// AESDECLAST m128 xmm 579// Construct and append a AESDECLAST instruction to the active function. 580func (c *Context) AESDECLAST(mx, x operand.Op) { 581 if inst, err := x86.AESDECLAST(mx, x); err == nil { 582 c.Instruction(inst) 583 } else { 584 c.adderror(err) 585 } 586} 587 588// AESDECLAST: Perform Last Round of an AES Decryption Flow. 589// 590// Forms: 591// 592// AESDECLAST xmm xmm 593// AESDECLAST m128 xmm 594// Construct and append a AESDECLAST instruction to the active function. 595// Operates on the global context. 596func AESDECLAST(mx, x operand.Op) { ctx.AESDECLAST(mx, x) } 597 598// AESENC: Perform One Round of an AES Encryption Flow. 599// 600// Forms: 601// 602// AESENC xmm xmm 603// AESENC m128 xmm 604// Construct and append a AESENC instruction to the active function. 605func (c *Context) AESENC(mx, x operand.Op) { 606 if inst, err := x86.AESENC(mx, x); err == nil { 607 c.Instruction(inst) 608 } else { 609 c.adderror(err) 610 } 611} 612 613// AESENC: Perform One Round of an AES Encryption Flow. 614// 615// Forms: 616// 617// AESENC xmm xmm 618// AESENC m128 xmm 619// Construct and append a AESENC instruction to the active function. 620// Operates on the global context. 621func AESENC(mx, x operand.Op) { ctx.AESENC(mx, x) } 622 623// AESENCLAST: Perform Last Round of an AES Encryption Flow. 624// 625// Forms: 626// 627// AESENCLAST xmm xmm 628// AESENCLAST m128 xmm 629// Construct and append a AESENCLAST instruction to the active function. 630func (c *Context) AESENCLAST(mx, x operand.Op) { 631 if inst, err := x86.AESENCLAST(mx, x); err == nil { 632 c.Instruction(inst) 633 } else { 634 c.adderror(err) 635 } 636} 637 638// AESENCLAST: Perform Last Round of an AES Encryption Flow. 639// 640// Forms: 641// 642// AESENCLAST xmm xmm 643// AESENCLAST m128 xmm 644// Construct and append a AESENCLAST instruction to the active function. 645// Operates on the global context. 646func AESENCLAST(mx, x operand.Op) { ctx.AESENCLAST(mx, x) } 647 648// AESIMC: Perform the AES InvMixColumn Transformation. 649// 650// Forms: 651// 652// AESIMC xmm xmm 653// AESIMC m128 xmm 654// Construct and append a AESIMC instruction to the active function. 655func (c *Context) AESIMC(mx, x operand.Op) { 656 if inst, err := x86.AESIMC(mx, x); err == nil { 657 c.Instruction(inst) 658 } else { 659 c.adderror(err) 660 } 661} 662 663// AESIMC: Perform the AES InvMixColumn Transformation. 664// 665// Forms: 666// 667// AESIMC xmm xmm 668// AESIMC m128 xmm 669// Construct and append a AESIMC instruction to the active function. 670// Operates on the global context. 671func AESIMC(mx, x operand.Op) { ctx.AESIMC(mx, x) } 672 673// AESKEYGENASSIST: AES Round Key Generation Assist. 674// 675// Forms: 676// 677// AESKEYGENASSIST imm8 xmm xmm 678// AESKEYGENASSIST imm8 m128 xmm 679// Construct and append a AESKEYGENASSIST instruction to the active function. 680func (c *Context) AESKEYGENASSIST(i, mx, x operand.Op) { 681 if inst, err := x86.AESKEYGENASSIST(i, mx, x); err == nil { 682 c.Instruction(inst) 683 } else { 684 c.adderror(err) 685 } 686} 687 688// AESKEYGENASSIST: AES Round Key Generation Assist. 689// 690// Forms: 691// 692// AESKEYGENASSIST imm8 xmm xmm 693// AESKEYGENASSIST imm8 m128 xmm 694// Construct and append a AESKEYGENASSIST instruction to the active function. 695// Operates on the global context. 696func AESKEYGENASSIST(i, mx, x operand.Op) { ctx.AESKEYGENASSIST(i, mx, x) } 697 698// ANDB: Logical AND. 699// 700// Forms: 701// 702// ANDB imm8 al 703// ANDB imm8 r8 704// ANDB r8 r8 705// ANDB m8 r8 706// ANDB imm8 m8 707// ANDB r8 m8 708// Construct and append a ANDB instruction to the active function. 709func (c *Context) ANDB(imr, amr operand.Op) { 710 if inst, err := x86.ANDB(imr, amr); err == nil { 711 c.Instruction(inst) 712 } else { 713 c.adderror(err) 714 } 715} 716 717// ANDB: Logical AND. 718// 719// Forms: 720// 721// ANDB imm8 al 722// ANDB imm8 r8 723// ANDB r8 r8 724// ANDB m8 r8 725// ANDB imm8 m8 726// ANDB r8 m8 727// Construct and append a ANDB instruction to the active function. 728// Operates on the global context. 729func ANDB(imr, amr operand.Op) { ctx.ANDB(imr, amr) } 730 731// ANDL: Logical AND. 732// 733// Forms: 734// 735// ANDL imm32 eax 736// ANDL imm8 r32 737// ANDL imm32 r32 738// ANDL r32 r32 739// ANDL m32 r32 740// ANDL imm8 m32 741// ANDL imm32 m32 742// ANDL r32 m32 743// Construct and append a ANDL instruction to the active function. 744func (c *Context) ANDL(imr, emr operand.Op) { 745 if inst, err := x86.ANDL(imr, emr); err == nil { 746 c.Instruction(inst) 747 } else { 748 c.adderror(err) 749 } 750} 751 752// ANDL: Logical AND. 753// 754// Forms: 755// 756// ANDL imm32 eax 757// ANDL imm8 r32 758// ANDL imm32 r32 759// ANDL r32 r32 760// ANDL m32 r32 761// ANDL imm8 m32 762// ANDL imm32 m32 763// ANDL r32 m32 764// Construct and append a ANDL instruction to the active function. 765// Operates on the global context. 766func ANDL(imr, emr operand.Op) { ctx.ANDL(imr, emr) } 767 768// ANDNL: Logical AND NOT. 769// 770// Forms: 771// 772// ANDNL r32 r32 r32 773// ANDNL m32 r32 r32 774// Construct and append a ANDNL instruction to the active function. 775func (c *Context) ANDNL(mr, r, r1 operand.Op) { 776 if inst, err := x86.ANDNL(mr, r, r1); err == nil { 777 c.Instruction(inst) 778 } else { 779 c.adderror(err) 780 } 781} 782 783// ANDNL: Logical AND NOT. 784// 785// Forms: 786// 787// ANDNL r32 r32 r32 788// ANDNL m32 r32 r32 789// Construct and append a ANDNL instruction to the active function. 790// Operates on the global context. 791func ANDNL(mr, r, r1 operand.Op) { ctx.ANDNL(mr, r, r1) } 792 793// ANDNPD: Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values. 794// 795// Forms: 796// 797// ANDNPD xmm xmm 798// ANDNPD m128 xmm 799// Construct and append a ANDNPD instruction to the active function. 800func (c *Context) ANDNPD(mx, x operand.Op) { 801 if inst, err := x86.ANDNPD(mx, x); err == nil { 802 c.Instruction(inst) 803 } else { 804 c.adderror(err) 805 } 806} 807 808// ANDNPD: Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values. 809// 810// Forms: 811// 812// ANDNPD xmm xmm 813// ANDNPD m128 xmm 814// Construct and append a ANDNPD instruction to the active function. 815// Operates on the global context. 816func ANDNPD(mx, x operand.Op) { ctx.ANDNPD(mx, x) } 817 818// ANDNPS: Bitwise Logical AND NOT of Packed Single-Precision Floating-Point Values. 819// 820// Forms: 821// 822// ANDNPS xmm xmm 823// ANDNPS m128 xmm 824// Construct and append a ANDNPS instruction to the active function. 825func (c *Context) ANDNPS(mx, x operand.Op) { 826 if inst, err := x86.ANDNPS(mx, x); err == nil { 827 c.Instruction(inst) 828 } else { 829 c.adderror(err) 830 } 831} 832 833// ANDNPS: Bitwise Logical AND NOT of Packed Single-Precision Floating-Point Values. 834// 835// Forms: 836// 837// ANDNPS xmm xmm 838// ANDNPS m128 xmm 839// Construct and append a ANDNPS instruction to the active function. 840// Operates on the global context. 841func ANDNPS(mx, x operand.Op) { ctx.ANDNPS(mx, x) } 842 843// ANDNQ: Logical AND NOT. 844// 845// Forms: 846// 847// ANDNQ r64 r64 r64 848// ANDNQ m64 r64 r64 849// Construct and append a ANDNQ instruction to the active function. 850func (c *Context) ANDNQ(mr, r, r1 operand.Op) { 851 if inst, err := x86.ANDNQ(mr, r, r1); err == nil { 852 c.Instruction(inst) 853 } else { 854 c.adderror(err) 855 } 856} 857 858// ANDNQ: Logical AND NOT. 859// 860// Forms: 861// 862// ANDNQ r64 r64 r64 863// ANDNQ m64 r64 r64 864// Construct and append a ANDNQ instruction to the active function. 865// Operates on the global context. 866func ANDNQ(mr, r, r1 operand.Op) { ctx.ANDNQ(mr, r, r1) } 867 868// ANDPD: Bitwise Logical AND of Packed Double-Precision Floating-Point Values. 869// 870// Forms: 871// 872// ANDPD xmm xmm 873// ANDPD m128 xmm 874// Construct and append a ANDPD instruction to the active function. 875func (c *Context) ANDPD(mx, x operand.Op) { 876 if inst, err := x86.ANDPD(mx, x); err == nil { 877 c.Instruction(inst) 878 } else { 879 c.adderror(err) 880 } 881} 882 883// ANDPD: Bitwise Logical AND of Packed Double-Precision Floating-Point Values. 884// 885// Forms: 886// 887// ANDPD xmm xmm 888// ANDPD m128 xmm 889// Construct and append a ANDPD instruction to the active function. 890// Operates on the global context. 891func ANDPD(mx, x operand.Op) { ctx.ANDPD(mx, x) } 892 893// ANDPS: Bitwise Logical AND of Packed Single-Precision Floating-Point Values. 894// 895// Forms: 896// 897// ANDPS xmm xmm 898// ANDPS m128 xmm 899// Construct and append a ANDPS instruction to the active function. 900func (c *Context) ANDPS(mx, x operand.Op) { 901 if inst, err := x86.ANDPS(mx, x); err == nil { 902 c.Instruction(inst) 903 } else { 904 c.adderror(err) 905 } 906} 907 908// ANDPS: Bitwise Logical AND of Packed Single-Precision Floating-Point Values. 909// 910// Forms: 911// 912// ANDPS xmm xmm 913// ANDPS m128 xmm 914// Construct and append a ANDPS instruction to the active function. 915// Operates on the global context. 916func ANDPS(mx, x operand.Op) { ctx.ANDPS(mx, x) } 917 918// ANDQ: Logical AND. 919// 920// Forms: 921// 922// ANDQ imm32 rax 923// ANDQ imm8 r64 924// ANDQ imm32 r64 925// ANDQ r64 r64 926// ANDQ m64 r64 927// ANDQ imm8 m64 928// ANDQ imm32 m64 929// ANDQ r64 m64 930// Construct and append a ANDQ instruction to the active function. 931func (c *Context) ANDQ(imr, mr operand.Op) { 932 if inst, err := x86.ANDQ(imr, mr); err == nil { 933 c.Instruction(inst) 934 } else { 935 c.adderror(err) 936 } 937} 938 939// ANDQ: Logical AND. 940// 941// Forms: 942// 943// ANDQ imm32 rax 944// ANDQ imm8 r64 945// ANDQ imm32 r64 946// ANDQ r64 r64 947// ANDQ m64 r64 948// ANDQ imm8 m64 949// ANDQ imm32 m64 950// ANDQ r64 m64 951// Construct and append a ANDQ instruction to the active function. 952// Operates on the global context. 953func ANDQ(imr, mr operand.Op) { ctx.ANDQ(imr, mr) } 954 955// ANDW: Logical AND. 956// 957// Forms: 958// 959// ANDW imm16 ax 960// ANDW imm8 r16 961// ANDW imm16 r16 962// ANDW r16 r16 963// ANDW m16 r16 964// ANDW imm8 m16 965// ANDW imm16 m16 966// ANDW r16 m16 967// Construct and append a ANDW instruction to the active function. 968func (c *Context) ANDW(imr, amr operand.Op) { 969 if inst, err := x86.ANDW(imr, amr); err == nil { 970 c.Instruction(inst) 971 } else { 972 c.adderror(err) 973 } 974} 975 976// ANDW: Logical AND. 977// 978// Forms: 979// 980// ANDW imm16 ax 981// ANDW imm8 r16 982// ANDW imm16 r16 983// ANDW r16 r16 984// ANDW m16 r16 985// ANDW imm8 m16 986// ANDW imm16 m16 987// ANDW r16 m16 988// Construct and append a ANDW instruction to the active function. 989// Operates on the global context. 990func ANDW(imr, amr operand.Op) { ctx.ANDW(imr, amr) } 991 992// BEXTRL: Bit Field Extract. 993// 994// Forms: 995// 996// BEXTRL r32 r32 r32 997// BEXTRL r32 m32 r32 998// Construct and append a BEXTRL instruction to the active function. 999func (c *Context) BEXTRL(r, mr, r1 operand.Op) { 1000 if inst, err := x86.BEXTRL(r, mr, r1); err == nil { 1001 c.Instruction(inst) 1002 } else { 1003 c.adderror(err) 1004 } 1005} 1006 1007// BEXTRL: Bit Field Extract. 1008// 1009// Forms: 1010// 1011// BEXTRL r32 r32 r32 1012// BEXTRL r32 m32 r32 1013// Construct and append a BEXTRL instruction to the active function. 1014// Operates on the global context. 1015func BEXTRL(r, mr, r1 operand.Op) { ctx.BEXTRL(r, mr, r1) } 1016 1017// BEXTRQ: Bit Field Extract. 1018// 1019// Forms: 1020// 1021// BEXTRQ r64 r64 r64 1022// BEXTRQ r64 m64 r64 1023// Construct and append a BEXTRQ instruction to the active function. 1024func (c *Context) BEXTRQ(r, mr, r1 operand.Op) { 1025 if inst, err := x86.BEXTRQ(r, mr, r1); err == nil { 1026 c.Instruction(inst) 1027 } else { 1028 c.adderror(err) 1029 } 1030} 1031 1032// BEXTRQ: Bit Field Extract. 1033// 1034// Forms: 1035// 1036// BEXTRQ r64 r64 r64 1037// BEXTRQ r64 m64 r64 1038// Construct and append a BEXTRQ instruction to the active function. 1039// Operates on the global context. 1040func BEXTRQ(r, mr, r1 operand.Op) { ctx.BEXTRQ(r, mr, r1) } 1041 1042// BLENDPD: Blend Packed Double Precision Floating-Point Values. 1043// 1044// Forms: 1045// 1046// BLENDPD imm8 xmm xmm 1047// BLENDPD imm8 m128 xmm 1048// Construct and append a BLENDPD instruction to the active function. 1049func (c *Context) BLENDPD(i, mx, x operand.Op) { 1050 if inst, err := x86.BLENDPD(i, mx, x); err == nil { 1051 c.Instruction(inst) 1052 } else { 1053 c.adderror(err) 1054 } 1055} 1056 1057// BLENDPD: Blend Packed Double Precision Floating-Point Values. 1058// 1059// Forms: 1060// 1061// BLENDPD imm8 xmm xmm 1062// BLENDPD imm8 m128 xmm 1063// Construct and append a BLENDPD instruction to the active function. 1064// Operates on the global context. 1065func BLENDPD(i, mx, x operand.Op) { ctx.BLENDPD(i, mx, x) } 1066 1067// BLENDPS: Blend Packed Single Precision Floating-Point Values. 1068// 1069// Forms: 1070// 1071// BLENDPS imm8 xmm xmm 1072// BLENDPS imm8 m128 xmm 1073// Construct and append a BLENDPS instruction to the active function. 1074func (c *Context) BLENDPS(i, mx, x operand.Op) { 1075 if inst, err := x86.BLENDPS(i, mx, x); err == nil { 1076 c.Instruction(inst) 1077 } else { 1078 c.adderror(err) 1079 } 1080} 1081 1082// BLENDPS: Blend Packed Single Precision Floating-Point Values. 1083// 1084// Forms: 1085// 1086// BLENDPS imm8 xmm xmm 1087// BLENDPS imm8 m128 xmm 1088// Construct and append a BLENDPS instruction to the active function. 1089// Operates on the global context. 1090func BLENDPS(i, mx, x operand.Op) { ctx.BLENDPS(i, mx, x) } 1091 1092// BLENDVPD: Variable Blend Packed Double Precision Floating-Point Values. 1093// 1094// Forms: 1095// 1096// BLENDVPD xmm0 xmm xmm 1097// BLENDVPD xmm0 m128 xmm 1098// Construct and append a BLENDVPD instruction to the active function. 1099func (c *Context) BLENDVPD(x, mx, x1 operand.Op) { 1100 if inst, err := x86.BLENDVPD(x, mx, x1); err == nil { 1101 c.Instruction(inst) 1102 } else { 1103 c.adderror(err) 1104 } 1105} 1106 1107// BLENDVPD: Variable Blend Packed Double Precision Floating-Point Values. 1108// 1109// Forms: 1110// 1111// BLENDVPD xmm0 xmm xmm 1112// BLENDVPD xmm0 m128 xmm 1113// Construct and append a BLENDVPD instruction to the active function. 1114// Operates on the global context. 1115func BLENDVPD(x, mx, x1 operand.Op) { ctx.BLENDVPD(x, mx, x1) } 1116 1117// BLENDVPS: Variable Blend Packed Single Precision Floating-Point Values. 1118// 1119// Forms: 1120// 1121// BLENDVPS xmm0 xmm xmm 1122// BLENDVPS xmm0 m128 xmm 1123// Construct and append a BLENDVPS instruction to the active function. 1124func (c *Context) BLENDVPS(x, mx, x1 operand.Op) { 1125 if inst, err := x86.BLENDVPS(x, mx, x1); err == nil { 1126 c.Instruction(inst) 1127 } else { 1128 c.adderror(err) 1129 } 1130} 1131 1132// BLENDVPS: Variable Blend Packed Single Precision Floating-Point Values. 1133// 1134// Forms: 1135// 1136// BLENDVPS xmm0 xmm xmm 1137// BLENDVPS xmm0 m128 xmm 1138// Construct and append a BLENDVPS instruction to the active function. 1139// Operates on the global context. 1140func BLENDVPS(x, mx, x1 operand.Op) { ctx.BLENDVPS(x, mx, x1) } 1141 1142// BLSIL: Isolate Lowest Set Bit. 1143// 1144// Forms: 1145// 1146// BLSIL r32 r32 1147// BLSIL m32 r32 1148// Construct and append a BLSIL instruction to the active function. 1149func (c *Context) BLSIL(mr, r operand.Op) { 1150 if inst, err := x86.BLSIL(mr, r); err == nil { 1151 c.Instruction(inst) 1152 } else { 1153 c.adderror(err) 1154 } 1155} 1156 1157// BLSIL: Isolate Lowest Set Bit. 1158// 1159// Forms: 1160// 1161// BLSIL r32 r32 1162// BLSIL m32 r32 1163// Construct and append a BLSIL instruction to the active function. 1164// Operates on the global context. 1165func BLSIL(mr, r operand.Op) { ctx.BLSIL(mr, r) } 1166 1167// BLSIQ: Isolate Lowest Set Bit. 1168// 1169// Forms: 1170// 1171// BLSIQ r64 r64 1172// BLSIQ m64 r64 1173// Construct and append a BLSIQ instruction to the active function. 1174func (c *Context) BLSIQ(mr, r operand.Op) { 1175 if inst, err := x86.BLSIQ(mr, r); err == nil { 1176 c.Instruction(inst) 1177 } else { 1178 c.adderror(err) 1179 } 1180} 1181 1182// BLSIQ: Isolate Lowest Set Bit. 1183// 1184// Forms: 1185// 1186// BLSIQ r64 r64 1187// BLSIQ m64 r64 1188// Construct and append a BLSIQ instruction to the active function. 1189// Operates on the global context. 1190func BLSIQ(mr, r operand.Op) { ctx.BLSIQ(mr, r) } 1191 1192// BLSMSKL: Mask From Lowest Set Bit. 1193// 1194// Forms: 1195// 1196// BLSMSKL r32 r32 1197// BLSMSKL m32 r32 1198// Construct and append a BLSMSKL instruction to the active function. 1199func (c *Context) BLSMSKL(mr, r operand.Op) { 1200 if inst, err := x86.BLSMSKL(mr, r); err == nil { 1201 c.Instruction(inst) 1202 } else { 1203 c.adderror(err) 1204 } 1205} 1206 1207// BLSMSKL: Mask From Lowest Set Bit. 1208// 1209// Forms: 1210// 1211// BLSMSKL r32 r32 1212// BLSMSKL m32 r32 1213// Construct and append a BLSMSKL instruction to the active function. 1214// Operates on the global context. 1215func BLSMSKL(mr, r operand.Op) { ctx.BLSMSKL(mr, r) } 1216 1217// BLSMSKQ: Mask From Lowest Set Bit. 1218// 1219// Forms: 1220// 1221// BLSMSKQ r64 r64 1222// BLSMSKQ m64 r64 1223// Construct and append a BLSMSKQ instruction to the active function. 1224func (c *Context) BLSMSKQ(mr, r operand.Op) { 1225 if inst, err := x86.BLSMSKQ(mr, r); err == nil { 1226 c.Instruction(inst) 1227 } else { 1228 c.adderror(err) 1229 } 1230} 1231 1232// BLSMSKQ: Mask From Lowest Set Bit. 1233// 1234// Forms: 1235// 1236// BLSMSKQ r64 r64 1237// BLSMSKQ m64 r64 1238// Construct and append a BLSMSKQ instruction to the active function. 1239// Operates on the global context. 1240func BLSMSKQ(mr, r operand.Op) { ctx.BLSMSKQ(mr, r) } 1241 1242// BLSRL: Reset Lowest Set Bit. 1243// 1244// Forms: 1245// 1246// BLSRL r32 r32 1247// BLSRL m32 r32 1248// Construct and append a BLSRL instruction to the active function. 1249func (c *Context) BLSRL(mr, r operand.Op) { 1250 if inst, err := x86.BLSRL(mr, r); err == nil { 1251 c.Instruction(inst) 1252 } else { 1253 c.adderror(err) 1254 } 1255} 1256 1257// BLSRL: Reset Lowest Set Bit. 1258// 1259// Forms: 1260// 1261// BLSRL r32 r32 1262// BLSRL m32 r32 1263// Construct and append a BLSRL instruction to the active function. 1264// Operates on the global context. 1265func BLSRL(mr, r operand.Op) { ctx.BLSRL(mr, r) } 1266 1267// BLSRQ: Reset Lowest Set Bit. 1268// 1269// Forms: 1270// 1271// BLSRQ r64 r64 1272// BLSRQ m64 r64 1273// Construct and append a BLSRQ instruction to the active function. 1274func (c *Context) BLSRQ(mr, r operand.Op) { 1275 if inst, err := x86.BLSRQ(mr, r); err == nil { 1276 c.Instruction(inst) 1277 } else { 1278 c.adderror(err) 1279 } 1280} 1281 1282// BLSRQ: Reset Lowest Set Bit. 1283// 1284// Forms: 1285// 1286// BLSRQ r64 r64 1287// BLSRQ m64 r64 1288// Construct and append a BLSRQ instruction to the active function. 1289// Operates on the global context. 1290func BLSRQ(mr, r operand.Op) { ctx.BLSRQ(mr, r) } 1291 1292// BSFL: Bit Scan Forward. 1293// 1294// Forms: 1295// 1296// BSFL r32 r32 1297// BSFL m32 r32 1298// Construct and append a BSFL instruction to the active function. 1299func (c *Context) BSFL(mr, r operand.Op) { 1300 if inst, err := x86.BSFL(mr, r); err == nil { 1301 c.Instruction(inst) 1302 } else { 1303 c.adderror(err) 1304 } 1305} 1306 1307// BSFL: Bit Scan Forward. 1308// 1309// Forms: 1310// 1311// BSFL r32 r32 1312// BSFL m32 r32 1313// Construct and append a BSFL instruction to the active function. 1314// Operates on the global context. 1315func BSFL(mr, r operand.Op) { ctx.BSFL(mr, r) } 1316 1317// BSFQ: Bit Scan Forward. 1318// 1319// Forms: 1320// 1321// BSFQ r64 r64 1322// BSFQ m64 r64 1323// Construct and append a BSFQ instruction to the active function. 1324func (c *Context) BSFQ(mr, r operand.Op) { 1325 if inst, err := x86.BSFQ(mr, r); err == nil { 1326 c.Instruction(inst) 1327 } else { 1328 c.adderror(err) 1329 } 1330} 1331 1332// BSFQ: Bit Scan Forward. 1333// 1334// Forms: 1335// 1336// BSFQ r64 r64 1337// BSFQ m64 r64 1338// Construct and append a BSFQ instruction to the active function. 1339// Operates on the global context. 1340func BSFQ(mr, r operand.Op) { ctx.BSFQ(mr, r) } 1341 1342// BSFW: Bit Scan Forward. 1343// 1344// Forms: 1345// 1346// BSFW r16 r16 1347// BSFW m16 r16 1348// Construct and append a BSFW instruction to the active function. 1349func (c *Context) BSFW(mr, r operand.Op) { 1350 if inst, err := x86.BSFW(mr, r); err == nil { 1351 c.Instruction(inst) 1352 } else { 1353 c.adderror(err) 1354 } 1355} 1356 1357// BSFW: Bit Scan Forward. 1358// 1359// Forms: 1360// 1361// BSFW r16 r16 1362// BSFW m16 r16 1363// Construct and append a BSFW instruction to the active function. 1364// Operates on the global context. 1365func BSFW(mr, r operand.Op) { ctx.BSFW(mr, r) } 1366 1367// BSRL: Bit Scan Reverse. 1368// 1369// Forms: 1370// 1371// BSRL r32 r32 1372// BSRL m32 r32 1373// Construct and append a BSRL instruction to the active function. 1374func (c *Context) BSRL(mr, r operand.Op) { 1375 if inst, err := x86.BSRL(mr, r); err == nil { 1376 c.Instruction(inst) 1377 } else { 1378 c.adderror(err) 1379 } 1380} 1381 1382// BSRL: Bit Scan Reverse. 1383// 1384// Forms: 1385// 1386// BSRL r32 r32 1387// BSRL m32 r32 1388// Construct and append a BSRL instruction to the active function. 1389// Operates on the global context. 1390func BSRL(mr, r operand.Op) { ctx.BSRL(mr, r) } 1391 1392// BSRQ: Bit Scan Reverse. 1393// 1394// Forms: 1395// 1396// BSRQ r64 r64 1397// BSRQ m64 r64 1398// Construct and append a BSRQ instruction to the active function. 1399func (c *Context) BSRQ(mr, r operand.Op) { 1400 if inst, err := x86.BSRQ(mr, r); err == nil { 1401 c.Instruction(inst) 1402 } else { 1403 c.adderror(err) 1404 } 1405} 1406 1407// BSRQ: Bit Scan Reverse. 1408// 1409// Forms: 1410// 1411// BSRQ r64 r64 1412// BSRQ m64 r64 1413// Construct and append a BSRQ instruction to the active function. 1414// Operates on the global context. 1415func BSRQ(mr, r operand.Op) { ctx.BSRQ(mr, r) } 1416 1417// BSRW: Bit Scan Reverse. 1418// 1419// Forms: 1420// 1421// BSRW r16 r16 1422// BSRW m16 r16 1423// Construct and append a BSRW instruction to the active function. 1424func (c *Context) BSRW(mr, r operand.Op) { 1425 if inst, err := x86.BSRW(mr, r); err == nil { 1426 c.Instruction(inst) 1427 } else { 1428 c.adderror(err) 1429 } 1430} 1431 1432// BSRW: Bit Scan Reverse. 1433// 1434// Forms: 1435// 1436// BSRW r16 r16 1437// BSRW m16 r16 1438// Construct and append a BSRW instruction to the active function. 1439// Operates on the global context. 1440func BSRW(mr, r operand.Op) { ctx.BSRW(mr, r) } 1441 1442// BSWAPL: Byte Swap. 1443// 1444// Forms: 1445// 1446// BSWAPL r32 1447// Construct and append a BSWAPL instruction to the active function. 1448func (c *Context) BSWAPL(r operand.Op) { 1449 if inst, err := x86.BSWAPL(r); err == nil { 1450 c.Instruction(inst) 1451 } else { 1452 c.adderror(err) 1453 } 1454} 1455 1456// BSWAPL: Byte Swap. 1457// 1458// Forms: 1459// 1460// BSWAPL r32 1461// Construct and append a BSWAPL instruction to the active function. 1462// Operates on the global context. 1463func BSWAPL(r operand.Op) { ctx.BSWAPL(r) } 1464 1465// BSWAPQ: Byte Swap. 1466// 1467// Forms: 1468// 1469// BSWAPQ r64 1470// Construct and append a BSWAPQ instruction to the active function. 1471func (c *Context) BSWAPQ(r operand.Op) { 1472 if inst, err := x86.BSWAPQ(r); err == nil { 1473 c.Instruction(inst) 1474 } else { 1475 c.adderror(err) 1476 } 1477} 1478 1479// BSWAPQ: Byte Swap. 1480// 1481// Forms: 1482// 1483// BSWAPQ r64 1484// Construct and append a BSWAPQ instruction to the active function. 1485// Operates on the global context. 1486func BSWAPQ(r operand.Op) { ctx.BSWAPQ(r) } 1487 1488// BTCL: Bit Test and Complement. 1489// 1490// Forms: 1491// 1492// BTCL imm8 r32 1493// BTCL r32 r32 1494// BTCL imm8 m32 1495// BTCL r32 m32 1496// Construct and append a BTCL instruction to the active function. 1497func (c *Context) BTCL(ir, mr operand.Op) { 1498 if inst, err := x86.BTCL(ir, mr); err == nil { 1499 c.Instruction(inst) 1500 } else { 1501 c.adderror(err) 1502 } 1503} 1504 1505// BTCL: Bit Test and Complement. 1506// 1507// Forms: 1508// 1509// BTCL imm8 r32 1510// BTCL r32 r32 1511// BTCL imm8 m32 1512// BTCL r32 m32 1513// Construct and append a BTCL instruction to the active function. 1514// Operates on the global context. 1515func BTCL(ir, mr operand.Op) { ctx.BTCL(ir, mr) } 1516 1517// BTCQ: Bit Test and Complement. 1518// 1519// Forms: 1520// 1521// BTCQ imm8 r64 1522// BTCQ r64 r64 1523// BTCQ imm8 m64 1524// BTCQ r64 m64 1525// Construct and append a BTCQ instruction to the active function. 1526func (c *Context) BTCQ(ir, mr operand.Op) { 1527 if inst, err := x86.BTCQ(ir, mr); err == nil { 1528 c.Instruction(inst) 1529 } else { 1530 c.adderror(err) 1531 } 1532} 1533 1534// BTCQ: Bit Test and Complement. 1535// 1536// Forms: 1537// 1538// BTCQ imm8 r64 1539// BTCQ r64 r64 1540// BTCQ imm8 m64 1541// BTCQ r64 m64 1542// Construct and append a BTCQ instruction to the active function. 1543// Operates on the global context. 1544func BTCQ(ir, mr operand.Op) { ctx.BTCQ(ir, mr) } 1545 1546// BTCW: Bit Test and Complement. 1547// 1548// Forms: 1549// 1550// BTCW imm8 r16 1551// BTCW r16 r16 1552// BTCW imm8 m16 1553// BTCW r16 m16 1554// Construct and append a BTCW instruction to the active function. 1555func (c *Context) BTCW(ir, mr operand.Op) { 1556 if inst, err := x86.BTCW(ir, mr); err == nil { 1557 c.Instruction(inst) 1558 } else { 1559 c.adderror(err) 1560 } 1561} 1562 1563// BTCW: Bit Test and Complement. 1564// 1565// Forms: 1566// 1567// BTCW imm8 r16 1568// BTCW r16 r16 1569// BTCW imm8 m16 1570// BTCW r16 m16 1571// Construct and append a BTCW instruction to the active function. 1572// Operates on the global context. 1573func BTCW(ir, mr operand.Op) { ctx.BTCW(ir, mr) } 1574 1575// BTL: Bit Test. 1576// 1577// Forms: 1578// 1579// BTL imm8 r32 1580// BTL r32 r32 1581// BTL imm8 m32 1582// BTL r32 m32 1583// Construct and append a BTL instruction to the active function. 1584func (c *Context) BTL(ir, mr operand.Op) { 1585 if inst, err := x86.BTL(ir, mr); err == nil { 1586 c.Instruction(inst) 1587 } else { 1588 c.adderror(err) 1589 } 1590} 1591 1592// BTL: Bit Test. 1593// 1594// Forms: 1595// 1596// BTL imm8 r32 1597// BTL r32 r32 1598// BTL imm8 m32 1599// BTL r32 m32 1600// Construct and append a BTL instruction to the active function. 1601// Operates on the global context. 1602func BTL(ir, mr operand.Op) { ctx.BTL(ir, mr) } 1603 1604// BTQ: Bit Test. 1605// 1606// Forms: 1607// 1608// BTQ imm8 r64 1609// BTQ r64 r64 1610// BTQ imm8 m64 1611// BTQ r64 m64 1612// Construct and append a BTQ instruction to the active function. 1613func (c *Context) BTQ(ir, mr operand.Op) { 1614 if inst, err := x86.BTQ(ir, mr); err == nil { 1615 c.Instruction(inst) 1616 } else { 1617 c.adderror(err) 1618 } 1619} 1620 1621// BTQ: Bit Test. 1622// 1623// Forms: 1624// 1625// BTQ imm8 r64 1626// BTQ r64 r64 1627// BTQ imm8 m64 1628// BTQ r64 m64 1629// Construct and append a BTQ instruction to the active function. 1630// Operates on the global context. 1631func BTQ(ir, mr operand.Op) { ctx.BTQ(ir, mr) } 1632 1633// BTRL: Bit Test and Reset. 1634// 1635// Forms: 1636// 1637// BTRL imm8 r32 1638// BTRL r32 r32 1639// BTRL imm8 m32 1640// BTRL r32 m32 1641// Construct and append a BTRL instruction to the active function. 1642func (c *Context) BTRL(ir, mr operand.Op) { 1643 if inst, err := x86.BTRL(ir, mr); err == nil { 1644 c.Instruction(inst) 1645 } else { 1646 c.adderror(err) 1647 } 1648} 1649 1650// BTRL: Bit Test and Reset. 1651// 1652// Forms: 1653// 1654// BTRL imm8 r32 1655// BTRL r32 r32 1656// BTRL imm8 m32 1657// BTRL r32 m32 1658// Construct and append a BTRL instruction to the active function. 1659// Operates on the global context. 1660func BTRL(ir, mr operand.Op) { ctx.BTRL(ir, mr) } 1661 1662// BTRQ: Bit Test and Reset. 1663// 1664// Forms: 1665// 1666// BTRQ imm8 r64 1667// BTRQ r64 r64 1668// BTRQ imm8 m64 1669// BTRQ r64 m64 1670// Construct and append a BTRQ instruction to the active function. 1671func (c *Context) BTRQ(ir, mr operand.Op) { 1672 if inst, err := x86.BTRQ(ir, mr); err == nil { 1673 c.Instruction(inst) 1674 } else { 1675 c.adderror(err) 1676 } 1677} 1678 1679// BTRQ: Bit Test and Reset. 1680// 1681// Forms: 1682// 1683// BTRQ imm8 r64 1684// BTRQ r64 r64 1685// BTRQ imm8 m64 1686// BTRQ r64 m64 1687// Construct and append a BTRQ instruction to the active function. 1688// Operates on the global context. 1689func BTRQ(ir, mr operand.Op) { ctx.BTRQ(ir, mr) } 1690 1691// BTRW: Bit Test and Reset. 1692// 1693// Forms: 1694// 1695// BTRW imm8 r16 1696// BTRW r16 r16 1697// BTRW imm8 m16 1698// BTRW r16 m16 1699// Construct and append a BTRW instruction to the active function. 1700func (c *Context) BTRW(ir, mr operand.Op) { 1701 if inst, err := x86.BTRW(ir, mr); err == nil { 1702 c.Instruction(inst) 1703 } else { 1704 c.adderror(err) 1705 } 1706} 1707 1708// BTRW: Bit Test and Reset. 1709// 1710// Forms: 1711// 1712// BTRW imm8 r16 1713// BTRW r16 r16 1714// BTRW imm8 m16 1715// BTRW r16 m16 1716// Construct and append a BTRW instruction to the active function. 1717// Operates on the global context. 1718func BTRW(ir, mr operand.Op) { ctx.BTRW(ir, mr) } 1719 1720// BTSL: Bit Test and Set. 1721// 1722// Forms: 1723// 1724// BTSL imm8 r32 1725// BTSL r32 r32 1726// BTSL imm8 m32 1727// BTSL r32 m32 1728// Construct and append a BTSL instruction to the active function. 1729func (c *Context) BTSL(ir, mr operand.Op) { 1730 if inst, err := x86.BTSL(ir, mr); err == nil { 1731 c.Instruction(inst) 1732 } else { 1733 c.adderror(err) 1734 } 1735} 1736 1737// BTSL: Bit Test and Set. 1738// 1739// Forms: 1740// 1741// BTSL imm8 r32 1742// BTSL r32 r32 1743// BTSL imm8 m32 1744// BTSL r32 m32 1745// Construct and append a BTSL instruction to the active function. 1746// Operates on the global context. 1747func BTSL(ir, mr operand.Op) { ctx.BTSL(ir, mr) } 1748 1749// BTSQ: Bit Test and Set. 1750// 1751// Forms: 1752// 1753// BTSQ imm8 r64 1754// BTSQ r64 r64 1755// BTSQ imm8 m64 1756// BTSQ r64 m64 1757// Construct and append a BTSQ instruction to the active function. 1758func (c *Context) BTSQ(ir, mr operand.Op) { 1759 if inst, err := x86.BTSQ(ir, mr); err == nil { 1760 c.Instruction(inst) 1761 } else { 1762 c.adderror(err) 1763 } 1764} 1765 1766// BTSQ: Bit Test and Set. 1767// 1768// Forms: 1769// 1770// BTSQ imm8 r64 1771// BTSQ r64 r64 1772// BTSQ imm8 m64 1773// BTSQ r64 m64 1774// Construct and append a BTSQ instruction to the active function. 1775// Operates on the global context. 1776func BTSQ(ir, mr operand.Op) { ctx.BTSQ(ir, mr) } 1777 1778// BTSW: Bit Test and Set. 1779// 1780// Forms: 1781// 1782// BTSW imm8 r16 1783// BTSW r16 r16 1784// BTSW imm8 m16 1785// BTSW r16 m16 1786// Construct and append a BTSW instruction to the active function. 1787func (c *Context) BTSW(ir, mr operand.Op) { 1788 if inst, err := x86.BTSW(ir, mr); err == nil { 1789 c.Instruction(inst) 1790 } else { 1791 c.adderror(err) 1792 } 1793} 1794 1795// BTSW: Bit Test and Set. 1796// 1797// Forms: 1798// 1799// BTSW imm8 r16 1800// BTSW r16 r16 1801// BTSW imm8 m16 1802// BTSW r16 m16 1803// Construct and append a BTSW instruction to the active function. 1804// Operates on the global context. 1805func BTSW(ir, mr operand.Op) { ctx.BTSW(ir, mr) } 1806 1807// BTW: Bit Test. 1808// 1809// Forms: 1810// 1811// BTW imm8 r16 1812// BTW r16 r16 1813// BTW imm8 m16 1814// BTW r16 m16 1815// Construct and append a BTW instruction to the active function. 1816func (c *Context) BTW(ir, mr operand.Op) { 1817 if inst, err := x86.BTW(ir, mr); err == nil { 1818 c.Instruction(inst) 1819 } else { 1820 c.adderror(err) 1821 } 1822} 1823 1824// BTW: Bit Test. 1825// 1826// Forms: 1827// 1828// BTW imm8 r16 1829// BTW r16 r16 1830// BTW imm8 m16 1831// BTW r16 m16 1832// Construct and append a BTW instruction to the active function. 1833// Operates on the global context. 1834func BTW(ir, mr operand.Op) { ctx.BTW(ir, mr) } 1835 1836// BZHIL: Zero High Bits Starting with Specified Bit Position. 1837// 1838// Forms: 1839// 1840// BZHIL r32 r32 r32 1841// BZHIL r32 m32 r32 1842// Construct and append a BZHIL instruction to the active function. 1843func (c *Context) BZHIL(r, mr, r1 operand.Op) { 1844 if inst, err := x86.BZHIL(r, mr, r1); err == nil { 1845 c.Instruction(inst) 1846 } else { 1847 c.adderror(err) 1848 } 1849} 1850 1851// BZHIL: Zero High Bits Starting with Specified Bit Position. 1852// 1853// Forms: 1854// 1855// BZHIL r32 r32 r32 1856// BZHIL r32 m32 r32 1857// Construct and append a BZHIL instruction to the active function. 1858// Operates on the global context. 1859func BZHIL(r, mr, r1 operand.Op) { ctx.BZHIL(r, mr, r1) } 1860 1861// BZHIQ: Zero High Bits Starting with Specified Bit Position. 1862// 1863// Forms: 1864// 1865// BZHIQ r64 r64 r64 1866// BZHIQ r64 m64 r64 1867// Construct and append a BZHIQ instruction to the active function. 1868func (c *Context) BZHIQ(r, mr, r1 operand.Op) { 1869 if inst, err := x86.BZHIQ(r, mr, r1); err == nil { 1870 c.Instruction(inst) 1871 } else { 1872 c.adderror(err) 1873 } 1874} 1875 1876// BZHIQ: Zero High Bits Starting with Specified Bit Position. 1877// 1878// Forms: 1879// 1880// BZHIQ r64 r64 r64 1881// BZHIQ r64 m64 r64 1882// Construct and append a BZHIQ instruction to the active function. 1883// Operates on the global context. 1884func BZHIQ(r, mr, r1 operand.Op) { ctx.BZHIQ(r, mr, r1) } 1885 1886// CALL: Call Procedure. 1887// 1888// Forms: 1889// 1890// CALL rel32 1891// Construct and append a CALL instruction to the active function. 1892func (c *Context) CALL(r operand.Op) { 1893 if inst, err := x86.CALL(r); err == nil { 1894 c.Instruction(inst) 1895 } else { 1896 c.adderror(err) 1897 } 1898} 1899 1900// CALL: Call Procedure. 1901// 1902// Forms: 1903// 1904// CALL rel32 1905// Construct and append a CALL instruction to the active function. 1906// Operates on the global context. 1907func CALL(r operand.Op) { ctx.CALL(r) } 1908 1909// CBW: Convert Byte to Word. 1910// 1911// Forms: 1912// 1913// CBW 1914// Construct and append a CBW instruction to the active function. 1915func (c *Context) CBW() { 1916 if inst, err := x86.CBW(); err == nil { 1917 c.Instruction(inst) 1918 } else { 1919 c.adderror(err) 1920 } 1921} 1922 1923// CBW: Convert Byte to Word. 1924// 1925// Forms: 1926// 1927// CBW 1928// Construct and append a CBW instruction to the active function. 1929// Operates on the global context. 1930func CBW() { ctx.CBW() } 1931 1932// CDQ: Convert Doubleword to Quadword. 1933// 1934// Forms: 1935// 1936// CDQ 1937// Construct and append a CDQ instruction to the active function. 1938func (c *Context) CDQ() { 1939 if inst, err := x86.CDQ(); err == nil { 1940 c.Instruction(inst) 1941 } else { 1942 c.adderror(err) 1943 } 1944} 1945 1946// CDQ: Convert Doubleword to Quadword. 1947// 1948// Forms: 1949// 1950// CDQ 1951// Construct and append a CDQ instruction to the active function. 1952// Operates on the global context. 1953func CDQ() { ctx.CDQ() } 1954 1955// CDQE: Convert Doubleword to Quadword. 1956// 1957// Forms: 1958// 1959// CDQE 1960// Construct and append a CDQE instruction to the active function. 1961func (c *Context) CDQE() { 1962 if inst, err := x86.CDQE(); err == nil { 1963 c.Instruction(inst) 1964 } else { 1965 c.adderror(err) 1966 } 1967} 1968 1969// CDQE: Convert Doubleword to Quadword. 1970// 1971// Forms: 1972// 1973// CDQE 1974// Construct and append a CDQE instruction to the active function. 1975// Operates on the global context. 1976func CDQE() { ctx.CDQE() } 1977 1978// CLC: Clear Carry Flag. 1979// 1980// Forms: 1981// 1982// CLC 1983// Construct and append a CLC instruction to the active function. 1984func (c *Context) CLC() { 1985 if inst, err := x86.CLC(); err == nil { 1986 c.Instruction(inst) 1987 } else { 1988 c.adderror(err) 1989 } 1990} 1991 1992// CLC: Clear Carry Flag. 1993// 1994// Forms: 1995// 1996// CLC 1997// Construct and append a CLC instruction to the active function. 1998// Operates on the global context. 1999func CLC() { ctx.CLC() } 2000 2001// CLD: Clear Direction Flag. 2002// 2003// Forms: 2004// 2005// CLD 2006// Construct and append a CLD instruction to the active function. 2007func (c *Context) CLD() { 2008 if inst, err := x86.CLD(); err == nil { 2009 c.Instruction(inst) 2010 } else { 2011 c.adderror(err) 2012 } 2013} 2014 2015// CLD: Clear Direction Flag. 2016// 2017// Forms: 2018// 2019// CLD 2020// Construct and append a CLD instruction to the active function. 2021// Operates on the global context. 2022func CLD() { ctx.CLD() } 2023 2024// CLFLUSH: Flush Cache Line. 2025// 2026// Forms: 2027// 2028// CLFLUSH m8 2029// Construct and append a CLFLUSH instruction to the active function. 2030func (c *Context) CLFLUSH(m operand.Op) { 2031 if inst, err := x86.CLFLUSH(m); err == nil { 2032 c.Instruction(inst) 2033 } else { 2034 c.adderror(err) 2035 } 2036} 2037 2038// CLFLUSH: Flush Cache Line. 2039// 2040// Forms: 2041// 2042// CLFLUSH m8 2043// Construct and append a CLFLUSH instruction to the active function. 2044// Operates on the global context. 2045func CLFLUSH(m operand.Op) { ctx.CLFLUSH(m) } 2046 2047// CLFLUSHOPT: Flush Cache Line Optimized. 2048// 2049// Forms: 2050// 2051// CLFLUSHOPT m8 2052// Construct and append a CLFLUSHOPT instruction to the active function. 2053func (c *Context) CLFLUSHOPT(m operand.Op) { 2054 if inst, err := x86.CLFLUSHOPT(m); err == nil { 2055 c.Instruction(inst) 2056 } else { 2057 c.adderror(err) 2058 } 2059} 2060 2061// CLFLUSHOPT: Flush Cache Line Optimized. 2062// 2063// Forms: 2064// 2065// CLFLUSHOPT m8 2066// Construct and append a CLFLUSHOPT instruction to the active function. 2067// Operates on the global context. 2068func CLFLUSHOPT(m operand.Op) { ctx.CLFLUSHOPT(m) } 2069 2070// CMC: Complement Carry Flag. 2071// 2072// Forms: 2073// 2074// CMC 2075// Construct and append a CMC instruction to the active function. 2076func (c *Context) CMC() { 2077 if inst, err := x86.CMC(); err == nil { 2078 c.Instruction(inst) 2079 } else { 2080 c.adderror(err) 2081 } 2082} 2083 2084// CMC: Complement Carry Flag. 2085// 2086// Forms: 2087// 2088// CMC 2089// Construct and append a CMC instruction to the active function. 2090// Operates on the global context. 2091func CMC() { ctx.CMC() } 2092 2093// CMOVLCC: Move if above or equal (CF == 0). 2094// 2095// Forms: 2096// 2097// CMOVLCC r32 r32 2098// CMOVLCC m32 r32 2099// Construct and append a CMOVLCC instruction to the active function. 2100func (c *Context) CMOVLCC(mr, r operand.Op) { 2101 if inst, err := x86.CMOVLCC(mr, r); err == nil { 2102 c.Instruction(inst) 2103 } else { 2104 c.adderror(err) 2105 } 2106} 2107 2108// CMOVLCC: Move if above or equal (CF == 0). 2109// 2110// Forms: 2111// 2112// CMOVLCC r32 r32 2113// CMOVLCC m32 r32 2114// Construct and append a CMOVLCC instruction to the active function. 2115// Operates on the global context. 2116func CMOVLCC(mr, r operand.Op) { ctx.CMOVLCC(mr, r) } 2117 2118// CMOVLCS: Move if below (CF == 1). 2119// 2120// Forms: 2121// 2122// CMOVLCS r32 r32 2123// CMOVLCS m32 r32 2124// Construct and append a CMOVLCS instruction to the active function. 2125func (c *Context) CMOVLCS(mr, r operand.Op) { 2126 if inst, err := x86.CMOVLCS(mr, r); err == nil { 2127 c.Instruction(inst) 2128 } else { 2129 c.adderror(err) 2130 } 2131} 2132 2133// CMOVLCS: Move if below (CF == 1). 2134// 2135// Forms: 2136// 2137// CMOVLCS r32 r32 2138// CMOVLCS m32 r32 2139// Construct and append a CMOVLCS instruction to the active function. 2140// Operates on the global context. 2141func CMOVLCS(mr, r operand.Op) { ctx.CMOVLCS(mr, r) } 2142 2143// CMOVLEQ: Move if equal (ZF == 1). 2144// 2145// Forms: 2146// 2147// CMOVLEQ r32 r32 2148// CMOVLEQ m32 r32 2149// Construct and append a CMOVLEQ instruction to the active function. 2150func (c *Context) CMOVLEQ(mr, r operand.Op) { 2151 if inst, err := x86.CMOVLEQ(mr, r); err == nil { 2152 c.Instruction(inst) 2153 } else { 2154 c.adderror(err) 2155 } 2156} 2157 2158// CMOVLEQ: Move if equal (ZF == 1). 2159// 2160// Forms: 2161// 2162// CMOVLEQ r32 r32 2163// CMOVLEQ m32 r32 2164// Construct and append a CMOVLEQ instruction to the active function. 2165// Operates on the global context. 2166func CMOVLEQ(mr, r operand.Op) { ctx.CMOVLEQ(mr, r) } 2167 2168// CMOVLGE: Move if greater or equal (SF == OF). 2169// 2170// Forms: 2171// 2172// CMOVLGE r32 r32 2173// CMOVLGE m32 r32 2174// Construct and append a CMOVLGE instruction to the active function. 2175func (c *Context) CMOVLGE(mr, r operand.Op) { 2176 if inst, err := x86.CMOVLGE(mr, r); err == nil { 2177 c.Instruction(inst) 2178 } else { 2179 c.adderror(err) 2180 } 2181} 2182 2183// CMOVLGE: Move if greater or equal (SF == OF). 2184// 2185// Forms: 2186// 2187// CMOVLGE r32 r32 2188// CMOVLGE m32 r32 2189// Construct and append a CMOVLGE instruction to the active function. 2190// Operates on the global context. 2191func CMOVLGE(mr, r operand.Op) { ctx.CMOVLGE(mr, r) } 2192 2193// CMOVLGT: Move if greater (ZF == 0 and SF == OF). 2194// 2195// Forms: 2196// 2197// CMOVLGT r32 r32 2198// CMOVLGT m32 r32 2199// Construct and append a CMOVLGT instruction to the active function. 2200func (c *Context) CMOVLGT(mr, r operand.Op) { 2201 if inst, err := x86.CMOVLGT(mr, r); err == nil { 2202 c.Instruction(inst) 2203 } else { 2204 c.adderror(err) 2205 } 2206} 2207 2208// CMOVLGT: Move if greater (ZF == 0 and SF == OF). 2209// 2210// Forms: 2211// 2212// CMOVLGT r32 r32 2213// CMOVLGT m32 r32 2214// Construct and append a CMOVLGT instruction to the active function. 2215// Operates on the global context. 2216func CMOVLGT(mr, r operand.Op) { ctx.CMOVLGT(mr, r) } 2217 2218// CMOVLHI: Move if above (CF == 0 and ZF == 0). 2219// 2220// Forms: 2221// 2222// CMOVLHI r32 r32 2223// CMOVLHI m32 r32 2224// Construct and append a CMOVLHI instruction to the active function. 2225func (c *Context) CMOVLHI(mr, r operand.Op) { 2226 if inst, err := x86.CMOVLHI(mr, r); err == nil { 2227 c.Instruction(inst) 2228 } else { 2229 c.adderror(err) 2230 } 2231} 2232 2233// CMOVLHI: Move if above (CF == 0 and ZF == 0). 2234// 2235// Forms: 2236// 2237// CMOVLHI r32 r32 2238// CMOVLHI m32 r32 2239// Construct and append a CMOVLHI instruction to the active function. 2240// Operates on the global context. 2241func CMOVLHI(mr, r operand.Op) { ctx.CMOVLHI(mr, r) } 2242 2243// CMOVLLE: Move if less or equal (ZF == 1 or SF != OF). 2244// 2245// Forms: 2246// 2247// CMOVLLE r32 r32 2248// CMOVLLE m32 r32 2249// Construct and append a CMOVLLE instruction to the active function. 2250func (c *Context) CMOVLLE(mr, r operand.Op) { 2251 if inst, err := x86.CMOVLLE(mr, r); err == nil { 2252 c.Instruction(inst) 2253 } else { 2254 c.adderror(err) 2255 } 2256} 2257 2258// CMOVLLE: Move if less or equal (ZF == 1 or SF != OF). 2259// 2260// Forms: 2261// 2262// CMOVLLE r32 r32 2263// CMOVLLE m32 r32 2264// Construct and append a CMOVLLE instruction to the active function. 2265// Operates on the global context. 2266func CMOVLLE(mr, r operand.Op) { ctx.CMOVLLE(mr, r) } 2267 2268// CMOVLLS: Move if below or equal (CF == 1 or ZF == 1). 2269// 2270// Forms: 2271// 2272// CMOVLLS r32 r32 2273// CMOVLLS m32 r32 2274// Construct and append a CMOVLLS instruction to the active function. 2275func (c *Context) CMOVLLS(mr, r operand.Op) { 2276 if inst, err := x86.CMOVLLS(mr, r); err == nil { 2277 c.Instruction(inst) 2278 } else { 2279 c.adderror(err) 2280 } 2281} 2282 2283// CMOVLLS: Move if below or equal (CF == 1 or ZF == 1). 2284// 2285// Forms: 2286// 2287// CMOVLLS r32 r32 2288// CMOVLLS m32 r32 2289// Construct and append a CMOVLLS instruction to the active function. 2290// Operates on the global context. 2291func CMOVLLS(mr, r operand.Op) { ctx.CMOVLLS(mr, r) } 2292 2293// CMOVLLT: Move if less (SF != OF). 2294// 2295// Forms: 2296// 2297// CMOVLLT r32 r32 2298// CMOVLLT m32 r32 2299// Construct and append a CMOVLLT instruction to the active function. 2300func (c *Context) CMOVLLT(mr, r operand.Op) { 2301 if inst, err := x86.CMOVLLT(mr, r); err == nil { 2302 c.Instruction(inst) 2303 } else { 2304 c.adderror(err) 2305 } 2306} 2307 2308// CMOVLLT: Move if less (SF != OF). 2309// 2310// Forms: 2311// 2312// CMOVLLT r32 r32 2313// CMOVLLT m32 r32 2314// Construct and append a CMOVLLT instruction to the active function. 2315// Operates on the global context. 2316func CMOVLLT(mr, r operand.Op) { ctx.CMOVLLT(mr, r) } 2317 2318// CMOVLMI: Move if sign (SF == 1). 2319// 2320// Forms: 2321// 2322// CMOVLMI r32 r32 2323// CMOVLMI m32 r32 2324// Construct and append a CMOVLMI instruction to the active function. 2325func (c *Context) CMOVLMI(mr, r operand.Op) { 2326 if inst, err := x86.CMOVLMI(mr, r); err == nil { 2327 c.Instruction(inst) 2328 } else { 2329 c.adderror(err) 2330 } 2331} 2332 2333// CMOVLMI: Move if sign (SF == 1). 2334// 2335// Forms: 2336// 2337// CMOVLMI r32 r32 2338// CMOVLMI m32 r32 2339// Construct and append a CMOVLMI instruction to the active function. 2340// Operates on the global context. 2341func CMOVLMI(mr, r operand.Op) { ctx.CMOVLMI(mr, r) } 2342 2343// CMOVLNE: Move if not equal (ZF == 0). 2344// 2345// Forms: 2346// 2347// CMOVLNE r32 r32 2348// CMOVLNE m32 r32 2349// Construct and append a CMOVLNE instruction to the active function. 2350func (c *Context) CMOVLNE(mr, r operand.Op) { 2351 if inst, err := x86.CMOVLNE(mr, r); err == nil { 2352 c.Instruction(inst) 2353 } else { 2354 c.adderror(err) 2355 } 2356} 2357 2358// CMOVLNE: Move if not equal (ZF == 0). 2359// 2360// Forms: 2361// 2362// CMOVLNE r32 r32 2363// CMOVLNE m32 r32 2364// Construct and append a CMOVLNE instruction to the active function. 2365// Operates on the global context. 2366func CMOVLNE(mr, r operand.Op) { ctx.CMOVLNE(mr, r) } 2367 2368// CMOVLOC: Move if not overflow (OF == 0). 2369// 2370// Forms: 2371// 2372// CMOVLOC r32 r32 2373// CMOVLOC m32 r32 2374// Construct and append a CMOVLOC instruction to the active function. 2375func (c *Context) CMOVLOC(mr, r operand.Op) { 2376 if inst, err := x86.CMOVLOC(mr, r); err == nil { 2377 c.Instruction(inst) 2378 } else { 2379 c.adderror(err) 2380 } 2381} 2382 2383// CMOVLOC: Move if not overflow (OF == 0). 2384// 2385// Forms: 2386// 2387// CMOVLOC r32 r32 2388// CMOVLOC m32 r32 2389// Construct and append a CMOVLOC instruction to the active function. 2390// Operates on the global context. 2391func CMOVLOC(mr, r operand.Op) { ctx.CMOVLOC(mr, r) } 2392 2393// CMOVLOS: Move if overflow (OF == 1). 2394// 2395// Forms: 2396// 2397// CMOVLOS r32 r32 2398// CMOVLOS m32 r32 2399// Construct and append a CMOVLOS instruction to the active function. 2400func (c *Context) CMOVLOS(mr, r operand.Op) { 2401 if inst, err := x86.CMOVLOS(mr, r); err == nil { 2402 c.Instruction(inst) 2403 } else { 2404 c.adderror(err) 2405 } 2406} 2407 2408// CMOVLOS: Move if overflow (OF == 1). 2409// 2410// Forms: 2411// 2412// CMOVLOS r32 r32 2413// CMOVLOS m32 r32 2414// Construct and append a CMOVLOS instruction to the active function. 2415// Operates on the global context. 2416func CMOVLOS(mr, r operand.Op) { ctx.CMOVLOS(mr, r) } 2417 2418// CMOVLPC: Move if not parity (PF == 0). 2419// 2420// Forms: 2421// 2422// CMOVLPC r32 r32 2423// CMOVLPC m32 r32 2424// Construct and append a CMOVLPC instruction to the active function. 2425func (c *Context) CMOVLPC(mr, r operand.Op) { 2426 if inst, err := x86.CMOVLPC(mr, r); err == nil { 2427 c.Instruction(inst) 2428 } else { 2429 c.adderror(err) 2430 } 2431} 2432 2433// CMOVLPC: Move if not parity (PF == 0). 2434// 2435// Forms: 2436// 2437// CMOVLPC r32 r32 2438// CMOVLPC m32 r32 2439// Construct and append a CMOVLPC instruction to the active function. 2440// Operates on the global context. 2441func CMOVLPC(mr, r operand.Op) { ctx.CMOVLPC(mr, r) } 2442 2443// CMOVLPL: Move if not sign (SF == 0). 2444// 2445// Forms: 2446// 2447// CMOVLPL r32 r32 2448// CMOVLPL m32 r32 2449// Construct and append a CMOVLPL instruction to the active function. 2450func (c *Context) CMOVLPL(mr, r operand.Op) { 2451 if inst, err := x86.CMOVLPL(mr, r); err == nil { 2452 c.Instruction(inst) 2453 } else { 2454 c.adderror(err) 2455 } 2456} 2457 2458// CMOVLPL: Move if not sign (SF == 0). 2459// 2460// Forms: 2461// 2462// CMOVLPL r32 r32 2463// CMOVLPL m32 r32 2464// Construct and append a CMOVLPL instruction to the active function. 2465// Operates on the global context. 2466func CMOVLPL(mr, r operand.Op) { ctx.CMOVLPL(mr, r) } 2467 2468// CMOVLPS: Move if parity (PF == 1). 2469// 2470// Forms: 2471// 2472// CMOVLPS r32 r32 2473// CMOVLPS m32 r32 2474// Construct and append a CMOVLPS instruction to the active function. 2475func (c *Context) CMOVLPS(mr, r operand.Op) { 2476 if inst, err := x86.CMOVLPS(mr, r); err == nil { 2477 c.Instruction(inst) 2478 } else { 2479 c.adderror(err) 2480 } 2481} 2482 2483// CMOVLPS: Move if parity (PF == 1). 2484// 2485// Forms: 2486// 2487// CMOVLPS r32 r32 2488// CMOVLPS m32 r32 2489// Construct and append a CMOVLPS instruction to the active function. 2490// Operates on the global context. 2491func CMOVLPS(mr, r operand.Op) { ctx.CMOVLPS(mr, r) } 2492 2493// CMOVQCC: Move if above or equal (CF == 0). 2494// 2495// Forms: 2496// 2497// CMOVQCC r64 r64 2498// CMOVQCC m64 r64 2499// Construct and append a CMOVQCC instruction to the active function. 2500func (c *Context) CMOVQCC(mr, r operand.Op) { 2501 if inst, err := x86.CMOVQCC(mr, r); err == nil { 2502 c.Instruction(inst) 2503 } else { 2504 c.adderror(err) 2505 } 2506} 2507 2508// CMOVQCC: Move if above or equal (CF == 0). 2509// 2510// Forms: 2511// 2512// CMOVQCC r64 r64 2513// CMOVQCC m64 r64 2514// Construct and append a CMOVQCC instruction to the active function. 2515// Operates on the global context. 2516func CMOVQCC(mr, r operand.Op) { ctx.CMOVQCC(mr, r) } 2517 2518// CMOVQCS: Move if below (CF == 1). 2519// 2520// Forms: 2521// 2522// CMOVQCS r64 r64 2523// CMOVQCS m64 r64 2524// Construct and append a CMOVQCS instruction to the active function. 2525func (c *Context) CMOVQCS(mr, r operand.Op) { 2526 if inst, err := x86.CMOVQCS(mr, r); err == nil { 2527 c.Instruction(inst) 2528 } else { 2529 c.adderror(err) 2530 } 2531} 2532 2533// CMOVQCS: Move if below (CF == 1). 2534// 2535// Forms: 2536// 2537// CMOVQCS r64 r64 2538// CMOVQCS m64 r64 2539// Construct and append a CMOVQCS instruction to the active function. 2540// Operates on the global context. 2541func CMOVQCS(mr, r operand.Op) { ctx.CMOVQCS(mr, r) } 2542 2543// CMOVQEQ: Move if equal (ZF == 1). 2544// 2545// Forms: 2546// 2547// CMOVQEQ r64 r64 2548// CMOVQEQ m64 r64 2549// Construct and append a CMOVQEQ instruction to the active function. 2550func (c *Context) CMOVQEQ(mr, r operand.Op) { 2551 if inst, err := x86.CMOVQEQ(mr, r); err == nil { 2552 c.Instruction(inst) 2553 } else { 2554 c.adderror(err) 2555 } 2556} 2557 2558// CMOVQEQ: Move if equal (ZF == 1). 2559// 2560// Forms: 2561// 2562// CMOVQEQ r64 r64 2563// CMOVQEQ m64 r64 2564// Construct and append a CMOVQEQ instruction to the active function. 2565// Operates on the global context. 2566func CMOVQEQ(mr, r operand.Op) { ctx.CMOVQEQ(mr, r) } 2567 2568// CMOVQGE: Move if greater or equal (SF == OF). 2569// 2570// Forms: 2571// 2572// CMOVQGE r64 r64 2573// CMOVQGE m64 r64 2574// Construct and append a CMOVQGE instruction to the active function. 2575func (c *Context) CMOVQGE(mr, r operand.Op) { 2576 if inst, err := x86.CMOVQGE(mr, r); err == nil { 2577 c.Instruction(inst) 2578 } else { 2579 c.adderror(err) 2580 } 2581} 2582 2583// CMOVQGE: Move if greater or equal (SF == OF). 2584// 2585// Forms: 2586// 2587// CMOVQGE r64 r64 2588// CMOVQGE m64 r64 2589// Construct and append a CMOVQGE instruction to the active function. 2590// Operates on the global context. 2591func CMOVQGE(mr, r operand.Op) { ctx.CMOVQGE(mr, r) } 2592 2593// CMOVQGT: Move if greater (ZF == 0 and SF == OF). 2594// 2595// Forms: 2596// 2597// CMOVQGT r64 r64 2598// CMOVQGT m64 r64 2599// Construct and append a CMOVQGT instruction to the active function. 2600func (c *Context) CMOVQGT(mr, r operand.Op) { 2601 if inst, err := x86.CMOVQGT(mr, r); err == nil { 2602 c.Instruction(inst) 2603 } else { 2604 c.adderror(err) 2605 } 2606} 2607 2608// CMOVQGT: Move if greater (ZF == 0 and SF == OF). 2609// 2610// Forms: 2611// 2612// CMOVQGT r64 r64 2613// CMOVQGT m64 r64 2614// Construct and append a CMOVQGT instruction to the active function. 2615// Operates on the global context. 2616func CMOVQGT(mr, r operand.Op) { ctx.CMOVQGT(mr, r) } 2617 2618// CMOVQHI: Move if above (CF == 0 and ZF == 0). 2619// 2620// Forms: 2621// 2622// CMOVQHI r64 r64 2623// CMOVQHI m64 r64 2624// Construct and append a CMOVQHI instruction to the active function. 2625func (c *Context) CMOVQHI(mr, r operand.Op) { 2626 if inst, err := x86.CMOVQHI(mr, r); err == nil { 2627 c.Instruction(inst) 2628 } else { 2629 c.adderror(err) 2630 } 2631} 2632 2633// CMOVQHI: Move if above (CF == 0 and ZF == 0). 2634// 2635// Forms: 2636// 2637// CMOVQHI r64 r64 2638// CMOVQHI m64 r64 2639// Construct and append a CMOVQHI instruction to the active function. 2640// Operates on the global context. 2641func CMOVQHI(mr, r operand.Op) { ctx.CMOVQHI(mr, r) } 2642 2643// CMOVQLE: Move if less or equal (ZF == 1 or SF != OF). 2644// 2645// Forms: 2646// 2647// CMOVQLE r64 r64 2648// CMOVQLE m64 r64 2649// Construct and append a CMOVQLE instruction to the active function. 2650func (c *Context) CMOVQLE(mr, r operand.Op) { 2651 if inst, err := x86.CMOVQLE(mr, r); err == nil { 2652 c.Instruction(inst) 2653 } else { 2654 c.adderror(err) 2655 } 2656} 2657 2658// CMOVQLE: Move if less or equal (ZF == 1 or SF != OF). 2659// 2660// Forms: 2661// 2662// CMOVQLE r64 r64 2663// CMOVQLE m64 r64 2664// Construct and append a CMOVQLE instruction to the active function. 2665// Operates on the global context. 2666func CMOVQLE(mr, r operand.Op) { ctx.CMOVQLE(mr, r) } 2667 2668// CMOVQLS: Move if below or equal (CF == 1 or ZF == 1). 2669// 2670// Forms: 2671// 2672// CMOVQLS r64 r64 2673// CMOVQLS m64 r64 2674// Construct and append a CMOVQLS instruction to the active function. 2675func (c *Context) CMOVQLS(mr, r operand.Op) { 2676 if inst, err := x86.CMOVQLS(mr, r); err == nil { 2677 c.Instruction(inst) 2678 } else { 2679 c.adderror(err) 2680 } 2681} 2682 2683// CMOVQLS: Move if below or equal (CF == 1 or ZF == 1). 2684// 2685// Forms: 2686// 2687// CMOVQLS r64 r64 2688// CMOVQLS m64 r64 2689// Construct and append a CMOVQLS instruction to the active function. 2690// Operates on the global context. 2691func CMOVQLS(mr, r operand.Op) { ctx.CMOVQLS(mr, r) } 2692 2693// CMOVQLT: Move if less (SF != OF). 2694// 2695// Forms: 2696// 2697// CMOVQLT r64 r64 2698// CMOVQLT m64 r64 2699// Construct and append a CMOVQLT instruction to the active function. 2700func (c *Context) CMOVQLT(mr, r operand.Op) { 2701 if inst, err := x86.CMOVQLT(mr, r); err == nil { 2702 c.Instruction(inst) 2703 } else { 2704 c.adderror(err) 2705 } 2706} 2707 2708// CMOVQLT: Move if less (SF != OF). 2709// 2710// Forms: 2711// 2712// CMOVQLT r64 r64 2713// CMOVQLT m64 r64 2714// Construct and append a CMOVQLT instruction to the active function. 2715// Operates on the global context. 2716func CMOVQLT(mr, r operand.Op) { ctx.CMOVQLT(mr, r) } 2717 2718// CMOVQMI: Move if sign (SF == 1). 2719// 2720// Forms: 2721// 2722// CMOVQMI r64 r64 2723// CMOVQMI m64 r64 2724// Construct and append a CMOVQMI instruction to the active function. 2725func (c *Context) CMOVQMI(mr, r operand.Op) { 2726 if inst, err := x86.CMOVQMI(mr, r); err == nil { 2727 c.Instruction(inst) 2728 } else { 2729 c.adderror(err) 2730 } 2731} 2732 2733// CMOVQMI: Move if sign (SF == 1). 2734// 2735// Forms: 2736// 2737// CMOVQMI r64 r64 2738// CMOVQMI m64 r64 2739// Construct and append a CMOVQMI instruction to the active function. 2740// Operates on the global context. 2741func CMOVQMI(mr, r operand.Op) { ctx.CMOVQMI(mr, r) } 2742 2743// CMOVQNE: Move if not equal (ZF == 0). 2744// 2745// Forms: 2746// 2747// CMOVQNE r64 r64 2748// CMOVQNE m64 r64 2749// Construct and append a CMOVQNE instruction to the active function. 2750func (c *Context) CMOVQNE(mr, r operand.Op) { 2751 if inst, err := x86.CMOVQNE(mr, r); err == nil { 2752 c.Instruction(inst) 2753 } else { 2754 c.adderror(err) 2755 } 2756} 2757 2758// CMOVQNE: Move if not equal (ZF == 0). 2759// 2760// Forms: 2761// 2762// CMOVQNE r64 r64 2763// CMOVQNE m64 r64 2764// Construct and append a CMOVQNE instruction to the active function. 2765// Operates on the global context. 2766func CMOVQNE(mr, r operand.Op) { ctx.CMOVQNE(mr, r) } 2767 2768// CMOVQOC: Move if not overflow (OF == 0). 2769// 2770// Forms: 2771// 2772// CMOVQOC r64 r64 2773// CMOVQOC m64 r64 2774// Construct and append a CMOVQOC instruction to the active function. 2775func (c *Context) CMOVQOC(mr, r operand.Op) { 2776 if inst, err := x86.CMOVQOC(mr, r); err == nil { 2777 c.Instruction(inst) 2778 } else { 2779 c.adderror(err) 2780 } 2781} 2782 2783// CMOVQOC: Move if not overflow (OF == 0). 2784// 2785// Forms: 2786// 2787// CMOVQOC r64 r64 2788// CMOVQOC m64 r64 2789// Construct and append a CMOVQOC instruction to the active function. 2790// Operates on the global context. 2791func CMOVQOC(mr, r operand.Op) { ctx.CMOVQOC(mr, r) } 2792 2793// CMOVQOS: Move if overflow (OF == 1). 2794// 2795// Forms: 2796// 2797// CMOVQOS r64 r64 2798// CMOVQOS m64 r64 2799// Construct and append a CMOVQOS instruction to the active function. 2800func (c *Context) CMOVQOS(mr, r operand.Op) { 2801 if inst, err := x86.CMOVQOS(mr, r); err == nil { 2802 c.Instruction(inst) 2803 } else { 2804 c.adderror(err) 2805 } 2806} 2807 2808// CMOVQOS: Move if overflow (OF == 1). 2809// 2810// Forms: 2811// 2812// CMOVQOS r64 r64 2813// CMOVQOS m64 r64 2814// Construct and append a CMOVQOS instruction to the active function. 2815// Operates on the global context. 2816func CMOVQOS(mr, r operand.Op) { ctx.CMOVQOS(mr, r) } 2817 2818// CMOVQPC: Move if not parity (PF == 0). 2819// 2820// Forms: 2821// 2822// CMOVQPC r64 r64 2823// CMOVQPC m64 r64 2824// Construct and append a CMOVQPC instruction to the active function. 2825func (c *Context) CMOVQPC(mr, r operand.Op) { 2826 if inst, err := x86.CMOVQPC(mr, r); err == nil { 2827 c.Instruction(inst) 2828 } else { 2829 c.adderror(err) 2830 } 2831} 2832 2833// CMOVQPC: Move if not parity (PF == 0). 2834// 2835// Forms: 2836// 2837// CMOVQPC r64 r64 2838// CMOVQPC m64 r64 2839// Construct and append a CMOVQPC instruction to the active function. 2840// Operates on the global context. 2841func CMOVQPC(mr, r operand.Op) { ctx.CMOVQPC(mr, r) } 2842 2843// CMOVQPL: Move if not sign (SF == 0). 2844// 2845// Forms: 2846// 2847// CMOVQPL r64 r64 2848// CMOVQPL m64 r64 2849// Construct and append a CMOVQPL instruction to the active function. 2850func (c *Context) CMOVQPL(mr, r operand.Op) { 2851 if inst, err := x86.CMOVQPL(mr, r); err == nil { 2852 c.Instruction(inst) 2853 } else { 2854 c.adderror(err) 2855 } 2856} 2857 2858// CMOVQPL: Move if not sign (SF == 0). 2859// 2860// Forms: 2861// 2862// CMOVQPL r64 r64 2863// CMOVQPL m64 r64 2864// Construct and append a CMOVQPL instruction to the active function. 2865// Operates on the global context. 2866func CMOVQPL(mr, r operand.Op) { ctx.CMOVQPL(mr, r) } 2867 2868// CMOVQPS: Move if parity (PF == 1). 2869// 2870// Forms: 2871// 2872// CMOVQPS r64 r64 2873// CMOVQPS m64 r64 2874// Construct and append a CMOVQPS instruction to the active function. 2875func (c *Context) CMOVQPS(mr, r operand.Op) { 2876 if inst, err := x86.CMOVQPS(mr, r); err == nil { 2877 c.Instruction(inst) 2878 } else { 2879 c.adderror(err) 2880 } 2881} 2882 2883// CMOVQPS: Move if parity (PF == 1). 2884// 2885// Forms: 2886// 2887// CMOVQPS r64 r64 2888// CMOVQPS m64 r64 2889// Construct and append a CMOVQPS instruction to the active function. 2890// Operates on the global context. 2891func CMOVQPS(mr, r operand.Op) { ctx.CMOVQPS(mr, r) } 2892 2893// CMOVWCC: Move if above or equal (CF == 0). 2894// 2895// Forms: 2896// 2897// CMOVWCC r16 r16 2898// CMOVWCC m16 r16 2899// Construct and append a CMOVWCC instruction to the active function. 2900func (c *Context) CMOVWCC(mr, r operand.Op) { 2901 if inst, err := x86.CMOVWCC(mr, r); err == nil { 2902 c.Instruction(inst) 2903 } else { 2904 c.adderror(err) 2905 } 2906} 2907 2908// CMOVWCC: Move if above or equal (CF == 0). 2909// 2910// Forms: 2911// 2912// CMOVWCC r16 r16 2913// CMOVWCC m16 r16 2914// Construct and append a CMOVWCC instruction to the active function. 2915// Operates on the global context. 2916func CMOVWCC(mr, r operand.Op) { ctx.CMOVWCC(mr, r) } 2917 2918// CMOVWCS: Move if below (CF == 1). 2919// 2920// Forms: 2921// 2922// CMOVWCS r16 r16 2923// CMOVWCS m16 r16 2924// Construct and append a CMOVWCS instruction to the active function. 2925func (c *Context) CMOVWCS(mr, r operand.Op) { 2926 if inst, err := x86.CMOVWCS(mr, r); err == nil { 2927 c.Instruction(inst) 2928 } else { 2929 c.adderror(err) 2930 } 2931} 2932 2933// CMOVWCS: Move if below (CF == 1). 2934// 2935// Forms: 2936// 2937// CMOVWCS r16 r16 2938// CMOVWCS m16 r16 2939// Construct and append a CMOVWCS instruction to the active function. 2940// Operates on the global context. 2941func CMOVWCS(mr, r operand.Op) { ctx.CMOVWCS(mr, r) } 2942 2943// CMOVWEQ: Move if equal (ZF == 1). 2944// 2945// Forms: 2946// 2947// CMOVWEQ r16 r16 2948// CMOVWEQ m16 r16 2949// Construct and append a CMOVWEQ instruction to the active function. 2950func (c *Context) CMOVWEQ(mr, r operand.Op) { 2951 if inst, err := x86.CMOVWEQ(mr, r); err == nil { 2952 c.Instruction(inst) 2953 } else { 2954 c.adderror(err) 2955 } 2956} 2957 2958// CMOVWEQ: Move if equal (ZF == 1). 2959// 2960// Forms: 2961// 2962// CMOVWEQ r16 r16 2963// CMOVWEQ m16 r16 2964// Construct and append a CMOVWEQ instruction to the active function. 2965// Operates on the global context. 2966func CMOVWEQ(mr, r operand.Op) { ctx.CMOVWEQ(mr, r) } 2967 2968// CMOVWGE: Move if greater or equal (SF == OF). 2969// 2970// Forms: 2971// 2972// CMOVWGE r16 r16 2973// CMOVWGE m16 r16 2974// Construct and append a CMOVWGE instruction to the active function. 2975func (c *Context) CMOVWGE(mr, r operand.Op) { 2976 if inst, err := x86.CMOVWGE(mr, r); err == nil { 2977 c.Instruction(inst) 2978 } else { 2979 c.adderror(err) 2980 } 2981} 2982 2983// CMOVWGE: Move if greater or equal (SF == OF). 2984// 2985// Forms: 2986// 2987// CMOVWGE r16 r16 2988// CMOVWGE m16 r16 2989// Construct and append a CMOVWGE instruction to the active function. 2990// Operates on the global context. 2991func CMOVWGE(mr, r operand.Op) { ctx.CMOVWGE(mr, r) } 2992 2993// CMOVWGT: Move if greater (ZF == 0 and SF == OF). 2994// 2995// Forms: 2996// 2997// CMOVWGT r16 r16 2998// CMOVWGT m16 r16 2999// Construct and append a CMOVWGT instruction to the active function. 3000func (c *Context) CMOVWGT(mr, r operand.Op) { 3001 if inst, err := x86.CMOVWGT(mr, r); err == nil { 3002 c.Instruction(inst) 3003 } else { 3004 c.adderror(err) 3005 } 3006} 3007 3008// CMOVWGT: Move if greater (ZF == 0 and SF == OF). 3009// 3010// Forms: 3011// 3012// CMOVWGT r16 r16 3013// CMOVWGT m16 r16 3014// Construct and append a CMOVWGT instruction to the active function. 3015// Operates on the global context. 3016func CMOVWGT(mr, r operand.Op) { ctx.CMOVWGT(mr, r) } 3017 3018// CMOVWHI: Move if above (CF == 0 and ZF == 0). 3019// 3020// Forms: 3021// 3022// CMOVWHI r16 r16 3023// CMOVWHI m16 r16 3024// Construct and append a CMOVWHI instruction to the active function. 3025func (c *Context) CMOVWHI(mr, r operand.Op) { 3026 if inst, err := x86.CMOVWHI(mr, r); err == nil { 3027 c.Instruction(inst) 3028 } else { 3029 c.adderror(err) 3030 } 3031} 3032 3033// CMOVWHI: Move if above (CF == 0 and ZF == 0). 3034// 3035// Forms: 3036// 3037// CMOVWHI r16 r16 3038// CMOVWHI m16 r16 3039// Construct and append a CMOVWHI instruction to the active function. 3040// Operates on the global context. 3041func CMOVWHI(mr, r operand.Op) { ctx.CMOVWHI(mr, r) } 3042 3043// CMOVWLE: Move if less or equal (ZF == 1 or SF != OF). 3044// 3045// Forms: 3046// 3047// CMOVWLE r16 r16 3048// CMOVWLE m16 r16 3049// Construct and append a CMOVWLE instruction to the active function. 3050func (c *Context) CMOVWLE(mr, r operand.Op) { 3051 if inst, err := x86.CMOVWLE(mr, r); err == nil { 3052 c.Instruction(inst) 3053 } else { 3054 c.adderror(err) 3055 } 3056} 3057 3058// CMOVWLE: Move if less or equal (ZF == 1 or SF != OF). 3059// 3060// Forms: 3061// 3062// CMOVWLE r16 r16 3063// CMOVWLE m16 r16 3064// Construct and append a CMOVWLE instruction to the active function. 3065// Operates on the global context. 3066func CMOVWLE(mr, r operand.Op) { ctx.CMOVWLE(mr, r) } 3067 3068// CMOVWLS: Move if below or equal (CF == 1 or ZF == 1). 3069// 3070// Forms: 3071// 3072// CMOVWLS r16 r16 3073// CMOVWLS m16 r16 3074// Construct and append a CMOVWLS instruction to the active function. 3075func (c *Context) CMOVWLS(mr, r operand.Op) { 3076 if inst, err := x86.CMOVWLS(mr, r); err == nil { 3077 c.Instruction(inst) 3078 } else { 3079 c.adderror(err) 3080 } 3081} 3082 3083// CMOVWLS: Move if below or equal (CF == 1 or ZF == 1). 3084// 3085// Forms: 3086// 3087// CMOVWLS r16 r16 3088// CMOVWLS m16 r16 3089// Construct and append a CMOVWLS instruction to the active function. 3090// Operates on the global context. 3091func CMOVWLS(mr, r operand.Op) { ctx.CMOVWLS(mr, r) } 3092 3093// CMOVWLT: Move if less (SF != OF). 3094// 3095// Forms: 3096// 3097// CMOVWLT r16 r16 3098// CMOVWLT m16 r16 3099// Construct and append a CMOVWLT instruction to the active function. 3100func (c *Context) CMOVWLT(mr, r operand.Op) { 3101 if inst, err := x86.CMOVWLT(mr, r); err == nil { 3102 c.Instruction(inst) 3103 } else { 3104 c.adderror(err) 3105 } 3106} 3107 3108// CMOVWLT: Move if less (SF != OF). 3109// 3110// Forms: 3111// 3112// CMOVWLT r16 r16 3113// CMOVWLT m16 r16 3114// Construct and append a CMOVWLT instruction to the active function. 3115// Operates on the global context. 3116func CMOVWLT(mr, r operand.Op) { ctx.CMOVWLT(mr, r) } 3117 3118// CMOVWMI: Move if sign (SF == 1). 3119// 3120// Forms: 3121// 3122// CMOVWMI r16 r16 3123// CMOVWMI m16 r16 3124// Construct and append a CMOVWMI instruction to the active function. 3125func (c *Context) CMOVWMI(mr, r operand.Op) { 3126 if inst, err := x86.CMOVWMI(mr, r); err == nil { 3127 c.Instruction(inst) 3128 } else { 3129 c.adderror(err) 3130 } 3131} 3132 3133// CMOVWMI: Move if sign (SF == 1). 3134// 3135// Forms: 3136// 3137// CMOVWMI r16 r16 3138// CMOVWMI m16 r16 3139// Construct and append a CMOVWMI instruction to the active function. 3140// Operates on the global context. 3141func CMOVWMI(mr, r operand.Op) { ctx.CMOVWMI(mr, r) } 3142 3143// CMOVWNE: Move if not equal (ZF == 0). 3144// 3145// Forms: 3146// 3147// CMOVWNE r16 r16 3148// CMOVWNE m16 r16 3149// Construct and append a CMOVWNE instruction to the active function. 3150func (c *Context) CMOVWNE(mr, r operand.Op) { 3151 if inst, err := x86.CMOVWNE(mr, r); err == nil { 3152 c.Instruction(inst) 3153 } else { 3154 c.adderror(err) 3155 } 3156} 3157 3158// CMOVWNE: Move if not equal (ZF == 0). 3159// 3160// Forms: 3161// 3162// CMOVWNE r16 r16 3163// CMOVWNE m16 r16 3164// Construct and append a CMOVWNE instruction to the active function. 3165// Operates on the global context. 3166func CMOVWNE(mr, r operand.Op) { ctx.CMOVWNE(mr, r) } 3167 3168// CMOVWOC: Move if not overflow (OF == 0). 3169// 3170// Forms: 3171// 3172// CMOVWOC r16 r16 3173// CMOVWOC m16 r16 3174// Construct and append a CMOVWOC instruction to the active function. 3175func (c *Context) CMOVWOC(mr, r operand.Op) { 3176 if inst, err := x86.CMOVWOC(mr, r); err == nil { 3177 c.Instruction(inst) 3178 } else { 3179 c.adderror(err) 3180 } 3181} 3182 3183// CMOVWOC: Move if not overflow (OF == 0). 3184// 3185// Forms: 3186// 3187// CMOVWOC r16 r16 3188// CMOVWOC m16 r16 3189// Construct and append a CMOVWOC instruction to the active function. 3190// Operates on the global context. 3191func CMOVWOC(mr, r operand.Op) { ctx.CMOVWOC(mr, r) } 3192 3193// CMOVWOS: Move if overflow (OF == 1). 3194// 3195// Forms: 3196// 3197// CMOVWOS r16 r16 3198// CMOVWOS m16 r16 3199// Construct and append a CMOVWOS instruction to the active function. 3200func (c *Context) CMOVWOS(mr, r operand.Op) { 3201 if inst, err := x86.CMOVWOS(mr, r); err == nil { 3202 c.Instruction(inst) 3203 } else { 3204 c.adderror(err) 3205 } 3206} 3207 3208// CMOVWOS: Move if overflow (OF == 1). 3209// 3210// Forms: 3211// 3212// CMOVWOS r16 r16 3213// CMOVWOS m16 r16 3214// Construct and append a CMOVWOS instruction to the active function. 3215// Operates on the global context. 3216func CMOVWOS(mr, r operand.Op) { ctx.CMOVWOS(mr, r) } 3217 3218// CMOVWPC: Move if not parity (PF == 0). 3219// 3220// Forms: 3221// 3222// CMOVWPC r16 r16 3223// CMOVWPC m16 r16 3224// Construct and append a CMOVWPC instruction to the active function. 3225func (c *Context) CMOVWPC(mr, r operand.Op) { 3226 if inst, err := x86.CMOVWPC(mr, r); err == nil { 3227 c.Instruction(inst) 3228 } else { 3229 c.adderror(err) 3230 } 3231} 3232 3233// CMOVWPC: Move if not parity (PF == 0). 3234// 3235// Forms: 3236// 3237// CMOVWPC r16 r16 3238// CMOVWPC m16 r16 3239// Construct and append a CMOVWPC instruction to the active function. 3240// Operates on the global context. 3241func CMOVWPC(mr, r operand.Op) { ctx.CMOVWPC(mr, r) } 3242 3243// CMOVWPL: Move if not sign (SF == 0). 3244// 3245// Forms: 3246// 3247// CMOVWPL r16 r16 3248// CMOVWPL m16 r16 3249// Construct and append a CMOVWPL instruction to the active function. 3250func (c *Context) CMOVWPL(mr, r operand.Op) { 3251 if inst, err := x86.CMOVWPL(mr, r); err == nil { 3252 c.Instruction(inst) 3253 } else { 3254 c.adderror(err) 3255 } 3256} 3257 3258// CMOVWPL: Move if not sign (SF == 0). 3259// 3260// Forms: 3261// 3262// CMOVWPL r16 r16 3263// CMOVWPL m16 r16 3264// Construct and append a CMOVWPL instruction to the active function. 3265// Operates on the global context. 3266func CMOVWPL(mr, r operand.Op) { ctx.CMOVWPL(mr, r) } 3267 3268// CMOVWPS: Move if parity (PF == 1). 3269// 3270// Forms: 3271// 3272// CMOVWPS r16 r16 3273// CMOVWPS m16 r16 3274// Construct and append a CMOVWPS instruction to the active function. 3275func (c *Context) CMOVWPS(mr, r operand.Op) { 3276 if inst, err := x86.CMOVWPS(mr, r); err == nil { 3277 c.Instruction(inst) 3278 } else { 3279 c.adderror(err) 3280 } 3281} 3282 3283// CMOVWPS: Move if parity (PF == 1). 3284// 3285// Forms: 3286// 3287// CMOVWPS r16 r16 3288// CMOVWPS m16 r16 3289// Construct and append a CMOVWPS instruction to the active function. 3290// Operates on the global context. 3291func CMOVWPS(mr, r operand.Op) { ctx.CMOVWPS(mr, r) } 3292 3293// CMPB: Compare Two Operands. 3294// 3295// Forms: 3296// 3297// CMPB al imm8 3298// CMPB r8 imm8 3299// CMPB r8 r8 3300// CMPB r8 m8 3301// CMPB m8 imm8 3302// CMPB m8 r8 3303// Construct and append a CMPB instruction to the active function. 3304func (c *Context) CMPB(amr, imr operand.Op) { 3305 if inst, err := x86.CMPB(amr, imr); err == nil { 3306 c.Instruction(inst) 3307 } else { 3308 c.adderror(err) 3309 } 3310} 3311 3312// CMPB: Compare Two Operands. 3313// 3314// Forms: 3315// 3316// CMPB al imm8 3317// CMPB r8 imm8 3318// CMPB r8 r8 3319// CMPB r8 m8 3320// CMPB m8 imm8 3321// CMPB m8 r8 3322// Construct and append a CMPB instruction to the active function. 3323// Operates on the global context. 3324func CMPB(amr, imr operand.Op) { ctx.CMPB(amr, imr) } 3325 3326// CMPL: Compare Two Operands. 3327// 3328// Forms: 3329// 3330// CMPL eax imm32 3331// CMPL r32 imm8 3332// CMPL r32 imm32 3333// CMPL r32 r32 3334// CMPL r32 m32 3335// CMPL m32 imm8 3336// CMPL m32 imm32 3337// CMPL m32 r32 3338// Construct and append a CMPL instruction to the active function. 3339func (c *Context) CMPL(emr, imr operand.Op) { 3340 if inst, err := x86.CMPL(emr, imr); err == nil { 3341 c.Instruction(inst) 3342 } else { 3343 c.adderror(err) 3344 } 3345} 3346 3347// CMPL: Compare Two Operands. 3348// 3349// Forms: 3350// 3351// CMPL eax imm32 3352// CMPL r32 imm8 3353// CMPL r32 imm32 3354// CMPL r32 r32 3355// CMPL r32 m32 3356// CMPL m32 imm8 3357// CMPL m32 imm32 3358// CMPL m32 r32 3359// Construct and append a CMPL instruction to the active function. 3360// Operates on the global context. 3361func CMPL(emr, imr operand.Op) { ctx.CMPL(emr, imr) } 3362 3363// CMPPD: Compare Packed Double-Precision Floating-Point Values. 3364// 3365// Forms: 3366// 3367// CMPPD xmm xmm imm8 3368// CMPPD m128 xmm imm8 3369// Construct and append a CMPPD instruction to the active function. 3370func (c *Context) CMPPD(mx, x, i operand.Op) { 3371 if inst, err := x86.CMPPD(mx, x, i); err == nil { 3372 c.Instruction(inst) 3373 } else { 3374 c.adderror(err) 3375 } 3376} 3377 3378// CMPPD: Compare Packed Double-Precision Floating-Point Values. 3379// 3380// Forms: 3381// 3382// CMPPD xmm xmm imm8 3383// CMPPD m128 xmm imm8 3384// Construct and append a CMPPD instruction to the active function. 3385// Operates on the global context. 3386func CMPPD(mx, x, i operand.Op) { ctx.CMPPD(mx, x, i) } 3387 3388// CMPPS: Compare Packed Single-Precision Floating-Point Values. 3389// 3390// Forms: 3391// 3392// CMPPS xmm xmm imm8 3393// CMPPS m128 xmm imm8 3394// Construct and append a CMPPS instruction to the active function. 3395func (c *Context) CMPPS(mx, x, i operand.Op) { 3396 if inst, err := x86.CMPPS(mx, x, i); err == nil { 3397 c.Instruction(inst) 3398 } else { 3399 c.adderror(err) 3400 } 3401} 3402 3403// CMPPS: Compare Packed Single-Precision Floating-Point Values. 3404// 3405// Forms: 3406// 3407// CMPPS xmm xmm imm8 3408// CMPPS m128 xmm imm8 3409// Construct and append a CMPPS instruction to the active function. 3410// Operates on the global context. 3411func CMPPS(mx, x, i operand.Op) { ctx.CMPPS(mx, x, i) } 3412 3413// CMPQ: Compare Two Operands. 3414// 3415// Forms: 3416// 3417// CMPQ rax imm32 3418// CMPQ r64 imm8 3419// CMPQ r64 imm32 3420// CMPQ r64 r64 3421// CMPQ r64 m64 3422// CMPQ m64 imm8 3423// CMPQ m64 imm32 3424// CMPQ m64 r64 3425// Construct and append a CMPQ instruction to the active function. 3426func (c *Context) CMPQ(mr, imr operand.Op) { 3427 if inst, err := x86.CMPQ(mr, imr); err == nil { 3428 c.Instruction(inst) 3429 } else { 3430 c.adderror(err) 3431 } 3432} 3433 3434// CMPQ: Compare Two Operands. 3435// 3436// Forms: 3437// 3438// CMPQ rax imm32 3439// CMPQ r64 imm8 3440// CMPQ r64 imm32 3441// CMPQ r64 r64 3442// CMPQ r64 m64 3443// CMPQ m64 imm8 3444// CMPQ m64 imm32 3445// CMPQ m64 r64 3446// Construct and append a CMPQ instruction to the active function. 3447// Operates on the global context. 3448func CMPQ(mr, imr operand.Op) { ctx.CMPQ(mr, imr) } 3449 3450// CMPSD: Compare Scalar Double-Precision Floating-Point Values. 3451// 3452// Forms: 3453// 3454// CMPSD xmm xmm imm8 3455// CMPSD m64 xmm imm8 3456// Construct and append a CMPSD instruction to the active function. 3457func (c *Context) CMPSD(mx, x, i operand.Op) { 3458 if inst, err := x86.CMPSD(mx, x, i); err == nil { 3459 c.Instruction(inst) 3460 } else { 3461 c.adderror(err) 3462 } 3463} 3464 3465// CMPSD: Compare Scalar Double-Precision Floating-Point Values. 3466// 3467// Forms: 3468// 3469// CMPSD xmm xmm imm8 3470// CMPSD m64 xmm imm8 3471// Construct and append a CMPSD instruction to the active function. 3472// Operates on the global context. 3473func CMPSD(mx, x, i operand.Op) { ctx.CMPSD(mx, x, i) } 3474 3475// CMPSS: Compare Scalar Single-Precision Floating-Point Values. 3476// 3477// Forms: 3478// 3479// CMPSS xmm xmm imm8 3480// CMPSS m32 xmm imm8 3481// Construct and append a CMPSS instruction to the active function. 3482func (c *Context) CMPSS(mx, x, i operand.Op) { 3483 if inst, err := x86.CMPSS(mx, x, i); err == nil { 3484 c.Instruction(inst) 3485 } else { 3486 c.adderror(err) 3487 } 3488} 3489 3490// CMPSS: Compare Scalar Single-Precision Floating-Point Values. 3491// 3492// Forms: 3493// 3494// CMPSS xmm xmm imm8 3495// CMPSS m32 xmm imm8 3496// Construct and append a CMPSS instruction to the active function. 3497// Operates on the global context. 3498func CMPSS(mx, x, i operand.Op) { ctx.CMPSS(mx, x, i) } 3499 3500// CMPW: Compare Two Operands. 3501// 3502// Forms: 3503// 3504// CMPW ax imm16 3505// CMPW r16 imm8 3506// CMPW r16 imm16 3507// CMPW r16 r16 3508// CMPW r16 m16 3509// CMPW m16 imm8 3510// CMPW m16 imm16 3511// CMPW m16 r16 3512// Construct and append a CMPW instruction to the active function. 3513func (c *Context) CMPW(amr, imr operand.Op) { 3514 if inst, err := x86.CMPW(amr, imr); err == nil { 3515 c.Instruction(inst) 3516 } else { 3517 c.adderror(err) 3518 } 3519} 3520 3521// CMPW: Compare Two Operands. 3522// 3523// Forms: 3524// 3525// CMPW ax imm16 3526// CMPW r16 imm8 3527// CMPW r16 imm16 3528// CMPW r16 r16 3529// CMPW r16 m16 3530// CMPW m16 imm8 3531// CMPW m16 imm16 3532// CMPW m16 r16 3533// Construct and append a CMPW instruction to the active function. 3534// Operates on the global context. 3535func CMPW(amr, imr operand.Op) { ctx.CMPW(amr, imr) } 3536 3537// CMPXCHG16B: Compare and Exchange 16 Bytes. 3538// 3539// Forms: 3540// 3541// CMPXCHG16B m128 3542// Construct and append a CMPXCHG16B instruction to the active function. 3543func (c *Context) CMPXCHG16B(m operand.Op) { 3544 if inst, err := x86.CMPXCHG16B(m); err == nil { 3545 c.Instruction(inst) 3546 } else { 3547 c.adderror(err) 3548 } 3549} 3550 3551// CMPXCHG16B: Compare and Exchange 16 Bytes. 3552// 3553// Forms: 3554// 3555// CMPXCHG16B m128 3556// Construct and append a CMPXCHG16B instruction to the active function. 3557// Operates on the global context. 3558func CMPXCHG16B(m operand.Op) { ctx.CMPXCHG16B(m) } 3559 3560// CMPXCHG8B: Compare and Exchange 8 Bytes. 3561// 3562// Forms: 3563// 3564// CMPXCHG8B m64 3565// Construct and append a CMPXCHG8B instruction to the active function. 3566func (c *Context) CMPXCHG8B(m operand.Op) { 3567 if inst, err := x86.CMPXCHG8B(m); err == nil { 3568 c.Instruction(inst) 3569 } else { 3570 c.adderror(err) 3571 } 3572} 3573 3574// CMPXCHG8B: Compare and Exchange 8 Bytes. 3575// 3576// Forms: 3577// 3578// CMPXCHG8B m64 3579// Construct and append a CMPXCHG8B instruction to the active function. 3580// Operates on the global context. 3581func CMPXCHG8B(m operand.Op) { ctx.CMPXCHG8B(m) } 3582 3583// CMPXCHGB: Compare and Exchange. 3584// 3585// Forms: 3586// 3587// CMPXCHGB r8 r8 3588// CMPXCHGB r8 m8 3589// Construct and append a CMPXCHGB instruction to the active function. 3590func (c *Context) CMPXCHGB(r, mr operand.Op) { 3591 if inst, err := x86.CMPXCHGB(r, mr); err == nil { 3592 c.Instruction(inst) 3593 } else { 3594 c.adderror(err) 3595 } 3596} 3597 3598// CMPXCHGB: Compare and Exchange. 3599// 3600// Forms: 3601// 3602// CMPXCHGB r8 r8 3603// CMPXCHGB r8 m8 3604// Construct and append a CMPXCHGB instruction to the active function. 3605// Operates on the global context. 3606func CMPXCHGB(r, mr operand.Op) { ctx.CMPXCHGB(r, mr) } 3607 3608// CMPXCHGL: Compare and Exchange. 3609// 3610// Forms: 3611// 3612// CMPXCHGL r32 r32 3613// CMPXCHGL r32 m32 3614// Construct and append a CMPXCHGL instruction to the active function. 3615func (c *Context) CMPXCHGL(r, mr operand.Op) { 3616 if inst, err := x86.CMPXCHGL(r, mr); err == nil { 3617 c.Instruction(inst) 3618 } else { 3619 c.adderror(err) 3620 } 3621} 3622 3623// CMPXCHGL: Compare and Exchange. 3624// 3625// Forms: 3626// 3627// CMPXCHGL r32 r32 3628// CMPXCHGL r32 m32 3629// Construct and append a CMPXCHGL instruction to the active function. 3630// Operates on the global context. 3631func CMPXCHGL(r, mr operand.Op) { ctx.CMPXCHGL(r, mr) } 3632 3633// CMPXCHGQ: Compare and Exchange. 3634// 3635// Forms: 3636// 3637// CMPXCHGQ r64 r64 3638// CMPXCHGQ r64 m64 3639// Construct and append a CMPXCHGQ instruction to the active function. 3640func (c *Context) CMPXCHGQ(r, mr operand.Op) { 3641 if inst, err := x86.CMPXCHGQ(r, mr); err == nil { 3642 c.Instruction(inst) 3643 } else { 3644 c.adderror(err) 3645 } 3646} 3647 3648// CMPXCHGQ: Compare and Exchange. 3649// 3650// Forms: 3651// 3652// CMPXCHGQ r64 r64 3653// CMPXCHGQ r64 m64 3654// Construct and append a CMPXCHGQ instruction to the active function. 3655// Operates on the global context. 3656func CMPXCHGQ(r, mr operand.Op) { ctx.CMPXCHGQ(r, mr) } 3657 3658// CMPXCHGW: Compare and Exchange. 3659// 3660// Forms: 3661// 3662// CMPXCHGW r16 r16 3663// CMPXCHGW r16 m16 3664// Construct and append a CMPXCHGW instruction to the active function. 3665func (c *Context) CMPXCHGW(r, mr operand.Op) { 3666 if inst, err := x86.CMPXCHGW(r, mr); err == nil { 3667 c.Instruction(inst) 3668 } else { 3669 c.adderror(err) 3670 } 3671} 3672 3673// CMPXCHGW: Compare and Exchange. 3674// 3675// Forms: 3676// 3677// CMPXCHGW r16 r16 3678// CMPXCHGW r16 m16 3679// Construct and append a CMPXCHGW instruction to the active function. 3680// Operates on the global context. 3681func CMPXCHGW(r, mr operand.Op) { ctx.CMPXCHGW(r, mr) } 3682 3683// COMISD: Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS. 3684// 3685// Forms: 3686// 3687// COMISD xmm xmm 3688// COMISD m64 xmm 3689// Construct and append a COMISD instruction to the active function. 3690func (c *Context) COMISD(mx, x operand.Op) { 3691 if inst, err := x86.COMISD(mx, x); err == nil { 3692 c.Instruction(inst) 3693 } else { 3694 c.adderror(err) 3695 } 3696} 3697 3698// COMISD: Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS. 3699// 3700// Forms: 3701// 3702// COMISD xmm xmm 3703// COMISD m64 xmm 3704// Construct and append a COMISD instruction to the active function. 3705// Operates on the global context. 3706func COMISD(mx, x operand.Op) { ctx.COMISD(mx, x) } 3707 3708// COMISS: Compare Scalar Ordered Single-Precision Floating-Point Values and Set EFLAGS. 3709// 3710// Forms: 3711// 3712// COMISS xmm xmm 3713// COMISS m32 xmm 3714// Construct and append a COMISS instruction to the active function. 3715func (c *Context) COMISS(mx, x operand.Op) { 3716 if inst, err := x86.COMISS(mx, x); err == nil { 3717 c.Instruction(inst) 3718 } else { 3719 c.adderror(err) 3720 } 3721} 3722 3723// COMISS: Compare Scalar Ordered Single-Precision Floating-Point Values and Set EFLAGS. 3724// 3725// Forms: 3726// 3727// COMISS xmm xmm 3728// COMISS m32 xmm 3729// Construct and append a COMISS instruction to the active function. 3730// Operates on the global context. 3731func COMISS(mx, x operand.Op) { ctx.COMISS(mx, x) } 3732 3733// CPUID: CPU Identification. 3734// 3735// Forms: 3736// 3737// CPUID 3738// Construct and append a CPUID instruction to the active function. 3739func (c *Context) CPUID() { 3740 if inst, err := x86.CPUID(); err == nil { 3741 c.Instruction(inst) 3742 } else { 3743 c.adderror(err) 3744 } 3745} 3746 3747// CPUID: CPU Identification. 3748// 3749// Forms: 3750// 3751// CPUID 3752// Construct and append a CPUID instruction to the active function. 3753// Operates on the global context. 3754func CPUID() { ctx.CPUID() } 3755 3756// CQO: Convert Quadword to Octaword. 3757// 3758// Forms: 3759// 3760// CQO 3761// Construct and append a CQO instruction to the active function. 3762func (c *Context) CQO() { 3763 if inst, err := x86.CQO(); err == nil { 3764 c.Instruction(inst) 3765 } else { 3766 c.adderror(err) 3767 } 3768} 3769 3770// CQO: Convert Quadword to Octaword. 3771// 3772// Forms: 3773// 3774// CQO 3775// Construct and append a CQO instruction to the active function. 3776// Operates on the global context. 3777func CQO() { ctx.CQO() } 3778 3779// CRC32B: Accumulate CRC32 Value. 3780// 3781// Forms: 3782// 3783// CRC32B r8 r32 3784// CRC32B m8 r32 3785// CRC32B r8 r64 3786// CRC32B m8 r64 3787// Construct and append a CRC32B instruction to the active function. 3788func (c *Context) CRC32B(mr, r operand.Op) { 3789 if inst, err := x86.CRC32B(mr, r); err == nil { 3790 c.Instruction(inst) 3791 } else { 3792 c.adderror(err) 3793 } 3794} 3795 3796// CRC32B: Accumulate CRC32 Value. 3797// 3798// Forms: 3799// 3800// CRC32B r8 r32 3801// CRC32B m8 r32 3802// CRC32B r8 r64 3803// CRC32B m8 r64 3804// Construct and append a CRC32B instruction to the active function. 3805// Operates on the global context. 3806func CRC32B(mr, r operand.Op) { ctx.CRC32B(mr, r) } 3807 3808// CRC32L: Accumulate CRC32 Value. 3809// 3810// Forms: 3811// 3812// CRC32L r32 r32 3813// CRC32L m32 r32 3814// Construct and append a CRC32L instruction to the active function. 3815func (c *Context) CRC32L(mr, r operand.Op) { 3816 if inst, err := x86.CRC32L(mr, r); err == nil { 3817 c.Instruction(inst) 3818 } else { 3819 c.adderror(err) 3820 } 3821} 3822 3823// CRC32L: Accumulate CRC32 Value. 3824// 3825// Forms: 3826// 3827// CRC32L r32 r32 3828// CRC32L m32 r32 3829// Construct and append a CRC32L instruction to the active function. 3830// Operates on the global context. 3831func CRC32L(mr, r operand.Op) { ctx.CRC32L(mr, r) } 3832 3833// CRC32Q: Accumulate CRC32 Value. 3834// 3835// Forms: 3836// 3837// CRC32Q r64 r64 3838// CRC32Q m64 r64 3839// Construct and append a CRC32Q instruction to the active function. 3840func (c *Context) CRC32Q(mr, r operand.Op) { 3841 if inst, err := x86.CRC32Q(mr, r); err == nil { 3842 c.Instruction(inst) 3843 } else { 3844 c.adderror(err) 3845 } 3846} 3847 3848// CRC32Q: Accumulate CRC32 Value. 3849// 3850// Forms: 3851// 3852// CRC32Q r64 r64 3853// CRC32Q m64 r64 3854// Construct and append a CRC32Q instruction to the active function. 3855// Operates on the global context. 3856func CRC32Q(mr, r operand.Op) { ctx.CRC32Q(mr, r) } 3857 3858// CRC32W: Accumulate CRC32 Value. 3859// 3860// Forms: 3861// 3862// CRC32W r16 r32 3863// CRC32W m16 r32 3864// Construct and append a CRC32W instruction to the active function. 3865func (c *Context) CRC32W(mr, r operand.Op) { 3866 if inst, err := x86.CRC32W(mr, r); err == nil { 3867 c.Instruction(inst) 3868 } else { 3869 c.adderror(err) 3870 } 3871} 3872 3873// CRC32W: Accumulate CRC32 Value. 3874// 3875// Forms: 3876// 3877// CRC32W r16 r32 3878// CRC32W m16 r32 3879// Construct and append a CRC32W instruction to the active function. 3880// Operates on the global context. 3881func CRC32W(mr, r operand.Op) { ctx.CRC32W(mr, r) } 3882 3883// CVTPD2PL: Convert Packed Double-Precision FP Values to Packed Dword Integers. 3884// 3885// Forms: 3886// 3887// CVTPD2PL xmm xmm 3888// CVTPD2PL m128 xmm 3889// Construct and append a CVTPD2PL instruction to the active function. 3890func (c *Context) CVTPD2PL(mx, x operand.Op) { 3891 if inst, err := x86.CVTPD2PL(mx, x); err == nil { 3892 c.Instruction(inst) 3893 } else { 3894 c.adderror(err) 3895 } 3896} 3897 3898// CVTPD2PL: Convert Packed Double-Precision FP Values to Packed Dword Integers. 3899// 3900// Forms: 3901// 3902// CVTPD2PL xmm xmm 3903// CVTPD2PL m128 xmm 3904// Construct and append a CVTPD2PL instruction to the active function. 3905// Operates on the global context. 3906func CVTPD2PL(mx, x operand.Op) { ctx.CVTPD2PL(mx, x) } 3907 3908// CVTPD2PS: Convert Packed Double-Precision FP Values to Packed Single-Precision FP Values. 3909// 3910// Forms: 3911// 3912// CVTPD2PS xmm xmm 3913// CVTPD2PS m128 xmm 3914// Construct and append a CVTPD2PS instruction to the active function. 3915func (c *Context) CVTPD2PS(mx, x operand.Op) { 3916 if inst, err := x86.CVTPD2PS(mx, x); err == nil { 3917 c.Instruction(inst) 3918 } else { 3919 c.adderror(err) 3920 } 3921} 3922 3923// CVTPD2PS: Convert Packed Double-Precision FP Values to Packed Single-Precision FP Values. 3924// 3925// Forms: 3926// 3927// CVTPD2PS xmm xmm 3928// CVTPD2PS m128 xmm 3929// Construct and append a CVTPD2PS instruction to the active function. 3930// Operates on the global context. 3931func CVTPD2PS(mx, x operand.Op) { ctx.CVTPD2PS(mx, x) } 3932 3933// CVTPL2PD: Convert Packed Dword Integers to Packed Double-Precision FP Values. 3934// 3935// Forms: 3936// 3937// CVTPL2PD xmm xmm 3938// CVTPL2PD m64 xmm 3939// Construct and append a CVTPL2PD instruction to the active function. 3940func (c *Context) CVTPL2PD(mx, x operand.Op) { 3941 if inst, err := x86.CVTPL2PD(mx, x); err == nil { 3942 c.Instruction(inst) 3943 } else { 3944 c.adderror(err) 3945 } 3946} 3947 3948// CVTPL2PD: Convert Packed Dword Integers to Packed Double-Precision FP Values. 3949// 3950// Forms: 3951// 3952// CVTPL2PD xmm xmm 3953// CVTPL2PD m64 xmm 3954// Construct and append a CVTPL2PD instruction to the active function. 3955// Operates on the global context. 3956func CVTPL2PD(mx, x operand.Op) { ctx.CVTPL2PD(mx, x) } 3957 3958// CVTPL2PS: Convert Packed Dword Integers to Packed Single-Precision FP Values. 3959// 3960// Forms: 3961// 3962// CVTPL2PS xmm xmm 3963// CVTPL2PS m128 xmm 3964// Construct and append a CVTPL2PS instruction to the active function. 3965func (c *Context) CVTPL2PS(mx, x operand.Op) { 3966 if inst, err := x86.CVTPL2PS(mx, x); err == nil { 3967 c.Instruction(inst) 3968 } else { 3969 c.adderror(err) 3970 } 3971} 3972 3973// CVTPL2PS: Convert Packed Dword Integers to Packed Single-Precision FP Values. 3974// 3975// Forms: 3976// 3977// CVTPL2PS xmm xmm 3978// CVTPL2PS m128 xmm 3979// Construct and append a CVTPL2PS instruction to the active function. 3980// Operates on the global context. 3981func CVTPL2PS(mx, x operand.Op) { ctx.CVTPL2PS(mx, x) } 3982 3983// CVTPS2PD: Convert Packed Single-Precision FP Values to Packed Double-Precision FP Values. 3984// 3985// Forms: 3986// 3987// CVTPS2PD xmm xmm 3988// CVTPS2PD m64 xmm 3989// Construct and append a CVTPS2PD instruction to the active function. 3990func (c *Context) CVTPS2PD(mx, x operand.Op) { 3991 if inst, err := x86.CVTPS2PD(mx, x); err == nil { 3992 c.Instruction(inst) 3993 } else { 3994 c.adderror(err) 3995 } 3996} 3997 3998// CVTPS2PD: Convert Packed Single-Precision FP Values to Packed Double-Precision FP Values. 3999// 4000// Forms: 4001// 4002// CVTPS2PD xmm xmm 4003// CVTPS2PD m64 xmm 4004// Construct and append a CVTPS2PD instruction to the active function. 4005// Operates on the global context. 4006func CVTPS2PD(mx, x operand.Op) { ctx.CVTPS2PD(mx, x) } 4007 4008// CVTPS2PL: Convert Packed Single-Precision FP Values to Packed Dword Integers. 4009// 4010// Forms: 4011// 4012// CVTPS2PL xmm xmm 4013// CVTPS2PL m128 xmm 4014// Construct and append a CVTPS2PL instruction to the active function. 4015func (c *Context) CVTPS2PL(mx, x operand.Op) { 4016 if inst, err := x86.CVTPS2PL(mx, x); err == nil { 4017 c.Instruction(inst) 4018 } else { 4019 c.adderror(err) 4020 } 4021} 4022 4023// CVTPS2PL: Convert Packed Single-Precision FP Values to Packed Dword Integers. 4024// 4025// Forms: 4026// 4027// CVTPS2PL xmm xmm 4028// CVTPS2PL m128 xmm 4029// Construct and append a CVTPS2PL instruction to the active function. 4030// Operates on the global context. 4031func CVTPS2PL(mx, x operand.Op) { ctx.CVTPS2PL(mx, x) } 4032 4033// CVTSD2SL: Convert Scalar Double-Precision FP Value to Integer. 4034// 4035// Forms: 4036// 4037// CVTSD2SL xmm r32 4038// CVTSD2SL m64 r32 4039// CVTSD2SL xmm r64 4040// CVTSD2SL m64 r64 4041// Construct and append a CVTSD2SL instruction to the active function. 4042func (c *Context) CVTSD2SL(mx, r operand.Op) { 4043 if inst, err := x86.CVTSD2SL(mx, r); err == nil { 4044 c.Instruction(inst) 4045 } else { 4046 c.adderror(err) 4047 } 4048} 4049 4050// CVTSD2SL: Convert Scalar Double-Precision FP Value to Integer. 4051// 4052// Forms: 4053// 4054// CVTSD2SL xmm r32 4055// CVTSD2SL m64 r32 4056// CVTSD2SL xmm r64 4057// CVTSD2SL m64 r64 4058// Construct and append a CVTSD2SL instruction to the active function. 4059// Operates on the global context. 4060func CVTSD2SL(mx, r operand.Op) { ctx.CVTSD2SL(mx, r) } 4061 4062// CVTSD2SS: Convert Scalar Double-Precision FP Value to Scalar Single-Precision FP Value. 4063// 4064// Forms: 4065// 4066// CVTSD2SS xmm xmm 4067// CVTSD2SS m64 xmm 4068// Construct and append a CVTSD2SS instruction to the active function. 4069func (c *Context) CVTSD2SS(mx, x operand.Op) { 4070 if inst, err := x86.CVTSD2SS(mx, x); err == nil { 4071 c.Instruction(inst) 4072 } else { 4073 c.adderror(err) 4074 } 4075} 4076 4077// CVTSD2SS: Convert Scalar Double-Precision FP Value to Scalar Single-Precision FP Value. 4078// 4079// Forms: 4080// 4081// CVTSD2SS xmm xmm 4082// CVTSD2SS m64 xmm 4083// Construct and append a CVTSD2SS instruction to the active function. 4084// Operates on the global context. 4085func CVTSD2SS(mx, x operand.Op) { ctx.CVTSD2SS(mx, x) } 4086 4087// CVTSL2SD: Convert Dword Integer to Scalar Double-Precision FP Value. 4088// 4089// Forms: 4090// 4091// CVTSL2SD r32 xmm 4092// CVTSL2SD m32 xmm 4093// Construct and append a CVTSL2SD instruction to the active function. 4094func (c *Context) CVTSL2SD(mr, x operand.Op) { 4095 if inst, err := x86.CVTSL2SD(mr, x); err == nil { 4096 c.Instruction(inst) 4097 } else { 4098 c.adderror(err) 4099 } 4100} 4101 4102// CVTSL2SD: Convert Dword Integer to Scalar Double-Precision FP Value. 4103// 4104// Forms: 4105// 4106// CVTSL2SD r32 xmm 4107// CVTSL2SD m32 xmm 4108// Construct and append a CVTSL2SD instruction to the active function. 4109// Operates on the global context. 4110func CVTSL2SD(mr, x operand.Op) { ctx.CVTSL2SD(mr, x) } 4111 4112// CVTSL2SS: Convert Dword Integer to Scalar Single-Precision FP Value. 4113// 4114// Forms: 4115// 4116// CVTSL2SS r32 xmm 4117// CVTSL2SS m32 xmm 4118// Construct and append a CVTSL2SS instruction to the active function. 4119func (c *Context) CVTSL2SS(mr, x operand.Op) { 4120 if inst, err := x86.CVTSL2SS(mr, x); err == nil { 4121 c.Instruction(inst) 4122 } else { 4123 c.adderror(err) 4124 } 4125} 4126 4127// CVTSL2SS: Convert Dword Integer to Scalar Single-Precision FP Value. 4128// 4129// Forms: 4130// 4131// CVTSL2SS r32 xmm 4132// CVTSL2SS m32 xmm 4133// Construct and append a CVTSL2SS instruction to the active function. 4134// Operates on the global context. 4135func CVTSL2SS(mr, x operand.Op) { ctx.CVTSL2SS(mr, x) } 4136 4137// CVTSQ2SD: Convert Dword Integer to Scalar Double-Precision FP Value. 4138// 4139// Forms: 4140// 4141// CVTSQ2SD r64 xmm 4142// CVTSQ2SD m64 xmm 4143// Construct and append a CVTSQ2SD instruction to the active function. 4144func (c *Context) CVTSQ2SD(mr, x operand.Op) { 4145 if inst, err := x86.CVTSQ2SD(mr, x); err == nil { 4146 c.Instruction(inst) 4147 } else { 4148 c.adderror(err) 4149 } 4150} 4151 4152// CVTSQ2SD: Convert Dword Integer to Scalar Double-Precision FP Value. 4153// 4154// Forms: 4155// 4156// CVTSQ2SD r64 xmm 4157// CVTSQ2SD m64 xmm 4158// Construct and append a CVTSQ2SD instruction to the active function. 4159// Operates on the global context. 4160func CVTSQ2SD(mr, x operand.Op) { ctx.CVTSQ2SD(mr, x) } 4161 4162// CVTSQ2SS: Convert Dword Integer to Scalar Single-Precision FP Value. 4163// 4164// Forms: 4165// 4166// CVTSQ2SS r64 xmm 4167// CVTSQ2SS m64 xmm 4168// Construct and append a CVTSQ2SS instruction to the active function. 4169func (c *Context) CVTSQ2SS(mr, x operand.Op) { 4170 if inst, err := x86.CVTSQ2SS(mr, x); err == nil { 4171 c.Instruction(inst) 4172 } else { 4173 c.adderror(err) 4174 } 4175} 4176 4177// CVTSQ2SS: Convert Dword Integer to Scalar Single-Precision FP Value. 4178// 4179// Forms: 4180// 4181// CVTSQ2SS r64 xmm 4182// CVTSQ2SS m64 xmm 4183// Construct and append a CVTSQ2SS instruction to the active function. 4184// Operates on the global context. 4185func CVTSQ2SS(mr, x operand.Op) { ctx.CVTSQ2SS(mr, x) } 4186 4187// CVTSS2SD: Convert Scalar Single-Precision FP Value to Scalar Double-Precision FP Value. 4188// 4189// Forms: 4190// 4191// CVTSS2SD xmm xmm 4192// CVTSS2SD m32 xmm 4193// Construct and append a CVTSS2SD instruction to the active function. 4194func (c *Context) CVTSS2SD(mx, x operand.Op) { 4195 if inst, err := x86.CVTSS2SD(mx, x); err == nil { 4196 c.Instruction(inst) 4197 } else { 4198 c.adderror(err) 4199 } 4200} 4201 4202// CVTSS2SD: Convert Scalar Single-Precision FP Value to Scalar Double-Precision FP Value. 4203// 4204// Forms: 4205// 4206// CVTSS2SD xmm xmm 4207// CVTSS2SD m32 xmm 4208// Construct and append a CVTSS2SD instruction to the active function. 4209// Operates on the global context. 4210func CVTSS2SD(mx, x operand.Op) { ctx.CVTSS2SD(mx, x) } 4211 4212// CVTSS2SL: Convert Scalar Single-Precision FP Value to Dword Integer. 4213// 4214// Forms: 4215// 4216// CVTSS2SL xmm r32 4217// CVTSS2SL m32 r32 4218// CVTSS2SL xmm r64 4219// CVTSS2SL m32 r64 4220// Construct and append a CVTSS2SL instruction to the active function. 4221func (c *Context) CVTSS2SL(mx, r operand.Op) { 4222 if inst, err := x86.CVTSS2SL(mx, r); err == nil { 4223 c.Instruction(inst) 4224 } else { 4225 c.adderror(err) 4226 } 4227} 4228 4229// CVTSS2SL: Convert Scalar Single-Precision FP Value to Dword Integer. 4230// 4231// Forms: 4232// 4233// CVTSS2SL xmm r32 4234// CVTSS2SL m32 r32 4235// CVTSS2SL xmm r64 4236// CVTSS2SL m32 r64 4237// Construct and append a CVTSS2SL instruction to the active function. 4238// Operates on the global context. 4239func CVTSS2SL(mx, r operand.Op) { ctx.CVTSS2SL(mx, r) } 4240 4241// CVTTPD2PL: Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers. 4242// 4243// Forms: 4244// 4245// CVTTPD2PL xmm xmm 4246// CVTTPD2PL m128 xmm 4247// Construct and append a CVTTPD2PL instruction to the active function. 4248func (c *Context) CVTTPD2PL(mx, x operand.Op) { 4249 if inst, err := x86.CVTTPD2PL(mx, x); err == nil { 4250 c.Instruction(inst) 4251 } else { 4252 c.adderror(err) 4253 } 4254} 4255 4256// CVTTPD2PL: Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers. 4257// 4258// Forms: 4259// 4260// CVTTPD2PL xmm xmm 4261// CVTTPD2PL m128 xmm 4262// Construct and append a CVTTPD2PL instruction to the active function. 4263// Operates on the global context. 4264func CVTTPD2PL(mx, x operand.Op) { ctx.CVTTPD2PL(mx, x) } 4265 4266// CVTTPS2PL: Convert with Truncation Packed Single-Precision FP Values to Packed Dword Integers. 4267// 4268// Forms: 4269// 4270// CVTTPS2PL xmm xmm 4271// CVTTPS2PL m128 xmm 4272// Construct and append a CVTTPS2PL instruction to the active function. 4273func (c *Context) CVTTPS2PL(mx, x operand.Op) { 4274 if inst, err := x86.CVTTPS2PL(mx, x); err == nil { 4275 c.Instruction(inst) 4276 } else { 4277 c.adderror(err) 4278 } 4279} 4280 4281// CVTTPS2PL: Convert with Truncation Packed Single-Precision FP Values to Packed Dword Integers. 4282// 4283// Forms: 4284// 4285// CVTTPS2PL xmm xmm 4286// CVTTPS2PL m128 xmm 4287// Construct and append a CVTTPS2PL instruction to the active function. 4288// Operates on the global context. 4289func CVTTPS2PL(mx, x operand.Op) { ctx.CVTTPS2PL(mx, x) } 4290 4291// CVTTSD2SL: Convert with Truncation Scalar Double-Precision FP Value to Signed Integer. 4292// 4293// Forms: 4294// 4295// CVTTSD2SL xmm r32 4296// CVTTSD2SL m64 r32 4297// Construct and append a CVTTSD2SL instruction to the active function. 4298func (c *Context) CVTTSD2SL(mx, r operand.Op) { 4299 if inst, err := x86.CVTTSD2SL(mx, r); err == nil { 4300 c.Instruction(inst) 4301 } else { 4302 c.adderror(err) 4303 } 4304} 4305 4306// CVTTSD2SL: Convert with Truncation Scalar Double-Precision FP Value to Signed Integer. 4307// 4308// Forms: 4309// 4310// CVTTSD2SL xmm r32 4311// CVTTSD2SL m64 r32 4312// Construct and append a CVTTSD2SL instruction to the active function. 4313// Operates on the global context. 4314func CVTTSD2SL(mx, r operand.Op) { ctx.CVTTSD2SL(mx, r) } 4315 4316// CVTTSD2SQ: Convert with Truncation Scalar Double-Precision FP Value to Signed Integer. 4317// 4318// Forms: 4319// 4320// CVTTSD2SQ xmm r64 4321// CVTTSD2SQ m64 r64 4322// Construct and append a CVTTSD2SQ instruction to the active function. 4323func (c *Context) CVTTSD2SQ(mx, r operand.Op) { 4324 if inst, err := x86.CVTTSD2SQ(mx, r); err == nil { 4325 c.Instruction(inst) 4326 } else { 4327 c.adderror(err) 4328 } 4329} 4330 4331// CVTTSD2SQ: Convert with Truncation Scalar Double-Precision FP Value to Signed Integer. 4332// 4333// Forms: 4334// 4335// CVTTSD2SQ xmm r64 4336// CVTTSD2SQ m64 r64 4337// Construct and append a CVTTSD2SQ instruction to the active function. 4338// Operates on the global context. 4339func CVTTSD2SQ(mx, r operand.Op) { ctx.CVTTSD2SQ(mx, r) } 4340 4341// CVTTSS2SL: Convert with Truncation Scalar Single-Precision FP Value to Dword Integer. 4342// 4343// Forms: 4344// 4345// CVTTSS2SL xmm r32 4346// CVTTSS2SL m32 r32 4347// CVTTSS2SL xmm r64 4348// CVTTSS2SL m32 r64 4349// Construct and append a CVTTSS2SL instruction to the active function. 4350func (c *Context) CVTTSS2SL(mx, r operand.Op) { 4351 if inst, err := x86.CVTTSS2SL(mx, r); err == nil { 4352 c.Instruction(inst) 4353 } else { 4354 c.adderror(err) 4355 } 4356} 4357 4358// CVTTSS2SL: Convert with Truncation Scalar Single-Precision FP Value to Dword Integer. 4359// 4360// Forms: 4361// 4362// CVTTSS2SL xmm r32 4363// CVTTSS2SL m32 r32 4364// CVTTSS2SL xmm r64 4365// CVTTSS2SL m32 r64 4366// Construct and append a CVTTSS2SL instruction to the active function. 4367// Operates on the global context. 4368func CVTTSS2SL(mx, r operand.Op) { ctx.CVTTSS2SL(mx, r) } 4369 4370// CWD: Convert Word to Doubleword. 4371// 4372// Forms: 4373// 4374// CWD 4375// Construct and append a CWD instruction to the active function. 4376func (c *Context) CWD() { 4377 if inst, err := x86.CWD(); err == nil { 4378 c.Instruction(inst) 4379 } else { 4380 c.adderror(err) 4381 } 4382} 4383 4384// CWD: Convert Word to Doubleword. 4385// 4386// Forms: 4387// 4388// CWD 4389// Construct and append a CWD instruction to the active function. 4390// Operates on the global context. 4391func CWD() { ctx.CWD() } 4392 4393// CWDE: Convert Word to Doubleword. 4394// 4395// Forms: 4396// 4397// CWDE 4398// Construct and append a CWDE instruction to the active function. 4399func (c *Context) CWDE() { 4400 if inst, err := x86.CWDE(); err == nil { 4401 c.Instruction(inst) 4402 } else { 4403 c.adderror(err) 4404 } 4405} 4406 4407// CWDE: Convert Word to Doubleword. 4408// 4409// Forms: 4410// 4411// CWDE 4412// Construct and append a CWDE instruction to the active function. 4413// Operates on the global context. 4414func CWDE() { ctx.CWDE() } 4415 4416// DECB: Decrement by 1. 4417// 4418// Forms: 4419// 4420// DECB r8 4421// DECB m8 4422// Construct and append a DECB instruction to the active function. 4423func (c *Context) DECB(mr operand.Op) { 4424 if inst, err := x86.DECB(mr); err == nil { 4425 c.Instruction(inst) 4426 } else { 4427 c.adderror(err) 4428 } 4429} 4430 4431// DECB: Decrement by 1. 4432// 4433// Forms: 4434// 4435// DECB r8 4436// DECB m8 4437// Construct and append a DECB instruction to the active function. 4438// Operates on the global context. 4439func DECB(mr operand.Op) { ctx.DECB(mr) } 4440 4441// DECL: Decrement by 1. 4442// 4443// Forms: 4444// 4445// DECL r32 4446// DECL m32 4447// Construct and append a DECL instruction to the active function. 4448func (c *Context) DECL(mr operand.Op) { 4449 if inst, err := x86.DECL(mr); err == nil { 4450 c.Instruction(inst) 4451 } else { 4452 c.adderror(err) 4453 } 4454} 4455 4456// DECL: Decrement by 1. 4457// 4458// Forms: 4459// 4460// DECL r32 4461// DECL m32 4462// Construct and append a DECL instruction to the active function. 4463// Operates on the global context. 4464func DECL(mr operand.Op) { ctx.DECL(mr) } 4465 4466// DECQ: Decrement by 1. 4467// 4468// Forms: 4469// 4470// DECQ r64 4471// DECQ m64 4472// Construct and append a DECQ instruction to the active function. 4473func (c *Context) DECQ(mr operand.Op) { 4474 if inst, err := x86.DECQ(mr); err == nil { 4475 c.Instruction(inst) 4476 } else { 4477 c.adderror(err) 4478 } 4479} 4480 4481// DECQ: Decrement by 1. 4482// 4483// Forms: 4484// 4485// DECQ r64 4486// DECQ m64 4487// Construct and append a DECQ instruction to the active function. 4488// Operates on the global context. 4489func DECQ(mr operand.Op) { ctx.DECQ(mr) } 4490 4491// DECW: Decrement by 1. 4492// 4493// Forms: 4494// 4495// DECW r16 4496// DECW m16 4497// Construct and append a DECW instruction to the active function. 4498func (c *Context) DECW(mr operand.Op) { 4499 if inst, err := x86.DECW(mr); err == nil { 4500 c.Instruction(inst) 4501 } else { 4502 c.adderror(err) 4503 } 4504} 4505 4506// DECW: Decrement by 1. 4507// 4508// Forms: 4509// 4510// DECW r16 4511// DECW m16 4512// Construct and append a DECW instruction to the active function. 4513// Operates on the global context. 4514func DECW(mr operand.Op) { ctx.DECW(mr) } 4515 4516// DIVB: Unsigned Divide. 4517// 4518// Forms: 4519// 4520// DIVB r8 4521// DIVB m8 4522// Construct and append a DIVB instruction to the active function. 4523func (c *Context) DIVB(mr operand.Op) { 4524 if inst, err := x86.DIVB(mr); err == nil { 4525 c.Instruction(inst) 4526 } else { 4527 c.adderror(err) 4528 } 4529} 4530 4531// DIVB: Unsigned Divide. 4532// 4533// Forms: 4534// 4535// DIVB r8 4536// DIVB m8 4537// Construct and append a DIVB instruction to the active function. 4538// Operates on the global context. 4539func DIVB(mr operand.Op) { ctx.DIVB(mr) } 4540 4541// DIVL: Unsigned Divide. 4542// 4543// Forms: 4544// 4545// DIVL r32 4546// DIVL m32 4547// Construct and append a DIVL instruction to the active function. 4548func (c *Context) DIVL(mr operand.Op) { 4549 if inst, err := x86.DIVL(mr); err == nil { 4550 c.Instruction(inst) 4551 } else { 4552 c.adderror(err) 4553 } 4554} 4555 4556// DIVL: Unsigned Divide. 4557// 4558// Forms: 4559// 4560// DIVL r32 4561// DIVL m32 4562// Construct and append a DIVL instruction to the active function. 4563// Operates on the global context. 4564func DIVL(mr operand.Op) { ctx.DIVL(mr) } 4565 4566// DIVPD: Divide Packed Double-Precision Floating-Point Values. 4567// 4568// Forms: 4569// 4570// DIVPD xmm xmm 4571// DIVPD m128 xmm 4572// Construct and append a DIVPD instruction to the active function. 4573func (c *Context) DIVPD(mx, x operand.Op) { 4574 if inst, err := x86.DIVPD(mx, x); err == nil { 4575 c.Instruction(inst) 4576 } else { 4577 c.adderror(err) 4578 } 4579} 4580 4581// DIVPD: Divide Packed Double-Precision Floating-Point Values. 4582// 4583// Forms: 4584// 4585// DIVPD xmm xmm 4586// DIVPD m128 xmm 4587// Construct and append a DIVPD instruction to the active function. 4588// Operates on the global context. 4589func DIVPD(mx, x operand.Op) { ctx.DIVPD(mx, x) } 4590 4591// DIVPS: Divide Packed Single-Precision Floating-Point Values. 4592// 4593// Forms: 4594// 4595// DIVPS xmm xmm 4596// DIVPS m128 xmm 4597// Construct and append a DIVPS instruction to the active function. 4598func (c *Context) DIVPS(mx, x operand.Op) { 4599 if inst, err := x86.DIVPS(mx, x); err == nil { 4600 c.Instruction(inst) 4601 } else { 4602 c.adderror(err) 4603 } 4604} 4605 4606// DIVPS: Divide Packed Single-Precision Floating-Point Values. 4607// 4608// Forms: 4609// 4610// DIVPS xmm xmm 4611// DIVPS m128 xmm 4612// Construct and append a DIVPS instruction to the active function. 4613// Operates on the global context. 4614func DIVPS(mx, x operand.Op) { ctx.DIVPS(mx, x) } 4615 4616// DIVQ: Unsigned Divide. 4617// 4618// Forms: 4619// 4620// DIVQ r64 4621// DIVQ m64 4622// Construct and append a DIVQ instruction to the active function. 4623func (c *Context) DIVQ(mr operand.Op) { 4624 if inst, err := x86.DIVQ(mr); err == nil { 4625 c.Instruction(inst) 4626 } else { 4627 c.adderror(err) 4628 } 4629} 4630 4631// DIVQ: Unsigned Divide. 4632// 4633// Forms: 4634// 4635// DIVQ r64 4636// DIVQ m64 4637// Construct and append a DIVQ instruction to the active function. 4638// Operates on the global context. 4639func DIVQ(mr operand.Op) { ctx.DIVQ(mr) } 4640 4641// DIVSD: Divide Scalar Double-Precision Floating-Point Values. 4642// 4643// Forms: 4644// 4645// DIVSD xmm xmm 4646// DIVSD m64 xmm 4647// Construct and append a DIVSD instruction to the active function. 4648func (c *Context) DIVSD(mx, x operand.Op) { 4649 if inst, err := x86.DIVSD(mx, x); err == nil { 4650 c.Instruction(inst) 4651 } else { 4652 c.adderror(err) 4653 } 4654} 4655 4656// DIVSD: Divide Scalar Double-Precision Floating-Point Values. 4657// 4658// Forms: 4659// 4660// DIVSD xmm xmm 4661// DIVSD m64 xmm 4662// Construct and append a DIVSD instruction to the active function. 4663// Operates on the global context. 4664func DIVSD(mx, x operand.Op) { ctx.DIVSD(mx, x) } 4665 4666// DIVSS: Divide Scalar Single-Precision Floating-Point Values. 4667// 4668// Forms: 4669// 4670// DIVSS xmm xmm 4671// DIVSS m32 xmm 4672// Construct and append a DIVSS instruction to the active function. 4673func (c *Context) DIVSS(mx, x operand.Op) { 4674 if inst, err := x86.DIVSS(mx, x); err == nil { 4675 c.Instruction(inst) 4676 } else { 4677 c.adderror(err) 4678 } 4679} 4680 4681// DIVSS: Divide Scalar Single-Precision Floating-Point Values. 4682// 4683// Forms: 4684// 4685// DIVSS xmm xmm 4686// DIVSS m32 xmm 4687// Construct and append a DIVSS instruction to the active function. 4688// Operates on the global context. 4689func DIVSS(mx, x operand.Op) { ctx.DIVSS(mx, x) } 4690 4691// DIVW: Unsigned Divide. 4692// 4693// Forms: 4694// 4695// DIVW r16 4696// DIVW m16 4697// Construct and append a DIVW instruction to the active function. 4698func (c *Context) DIVW(mr operand.Op) { 4699 if inst, err := x86.DIVW(mr); err == nil { 4700 c.Instruction(inst) 4701 } else { 4702 c.adderror(err) 4703 } 4704} 4705 4706// DIVW: Unsigned Divide. 4707// 4708// Forms: 4709// 4710// DIVW r16 4711// DIVW m16 4712// Construct and append a DIVW instruction to the active function. 4713// Operates on the global context. 4714func DIVW(mr operand.Op) { ctx.DIVW(mr) } 4715 4716// DPPD: Dot Product of Packed Double Precision Floating-Point Values. 4717// 4718// Forms: 4719// 4720// DPPD imm8 xmm xmm 4721// DPPD imm8 m128 xmm 4722// Construct and append a DPPD instruction to the active function. 4723func (c *Context) DPPD(i, mx, x operand.Op) { 4724 if inst, err := x86.DPPD(i, mx, x); err == nil { 4725 c.Instruction(inst) 4726 } else { 4727 c.adderror(err) 4728 } 4729} 4730 4731// DPPD: Dot Product of Packed Double Precision Floating-Point Values. 4732// 4733// Forms: 4734// 4735// DPPD imm8 xmm xmm 4736// DPPD imm8 m128 xmm 4737// Construct and append a DPPD instruction to the active function. 4738// Operates on the global context. 4739func DPPD(i, mx, x operand.Op) { ctx.DPPD(i, mx, x) } 4740 4741// DPPS: Dot Product of Packed Single Precision Floating-Point Values. 4742// 4743// Forms: 4744// 4745// DPPS imm8 xmm xmm 4746// DPPS imm8 m128 xmm 4747// Construct and append a DPPS instruction to the active function. 4748func (c *Context) DPPS(i, mx, x operand.Op) { 4749 if inst, err := x86.DPPS(i, mx, x); err == nil { 4750 c.Instruction(inst) 4751 } else { 4752 c.adderror(err) 4753 } 4754} 4755 4756// DPPS: Dot Product of Packed Single Precision Floating-Point Values. 4757// 4758// Forms: 4759// 4760// DPPS imm8 xmm xmm 4761// DPPS imm8 m128 xmm 4762// Construct and append a DPPS instruction to the active function. 4763// Operates on the global context. 4764func DPPS(i, mx, x operand.Op) { ctx.DPPS(i, mx, x) } 4765 4766// EXTRACTPS: Extract Packed Single Precision Floating-Point Value. 4767// 4768// Forms: 4769// 4770// EXTRACTPS imm2u xmm r32 4771// EXTRACTPS imm2u xmm m32 4772// Construct and append a EXTRACTPS instruction to the active function. 4773func (c *Context) EXTRACTPS(i, x, mr operand.Op) { 4774 if inst, err := x86.EXTRACTPS(i, x, mr); err == nil { 4775 c.Instruction(inst) 4776 } else { 4777 c.adderror(err) 4778 } 4779} 4780 4781// EXTRACTPS: Extract Packed Single Precision Floating-Point Value. 4782// 4783// Forms: 4784// 4785// EXTRACTPS imm2u xmm r32 4786// EXTRACTPS imm2u xmm m32 4787// Construct and append a EXTRACTPS instruction to the active function. 4788// Operates on the global context. 4789func EXTRACTPS(i, x, mr operand.Op) { ctx.EXTRACTPS(i, x, mr) } 4790 4791// HADDPD: Packed Double-FP Horizontal Add. 4792// 4793// Forms: 4794// 4795// HADDPD xmm xmm 4796// HADDPD m128 xmm 4797// Construct and append a HADDPD instruction to the active function. 4798func (c *Context) HADDPD(mx, x operand.Op) { 4799 if inst, err := x86.HADDPD(mx, x); err == nil { 4800 c.Instruction(inst) 4801 } else { 4802 c.adderror(err) 4803 } 4804} 4805 4806// HADDPD: Packed Double-FP Horizontal Add. 4807// 4808// Forms: 4809// 4810// HADDPD xmm xmm 4811// HADDPD m128 xmm 4812// Construct and append a HADDPD instruction to the active function. 4813// Operates on the global context. 4814func HADDPD(mx, x operand.Op) { ctx.HADDPD(mx, x) } 4815 4816// HADDPS: Packed Single-FP Horizontal Add. 4817// 4818// Forms: 4819// 4820// HADDPS xmm xmm 4821// HADDPS m128 xmm 4822// Construct and append a HADDPS instruction to the active function. 4823func (c *Context) HADDPS(mx, x operand.Op) { 4824 if inst, err := x86.HADDPS(mx, x); err == nil { 4825 c.Instruction(inst) 4826 } else { 4827 c.adderror(err) 4828 } 4829} 4830 4831// HADDPS: Packed Single-FP Horizontal Add. 4832// 4833// Forms: 4834// 4835// HADDPS xmm xmm 4836// HADDPS m128 xmm 4837// Construct and append a HADDPS instruction to the active function. 4838// Operates on the global context. 4839func HADDPS(mx, x operand.Op) { ctx.HADDPS(mx, x) } 4840 4841// HSUBPD: Packed Double-FP Horizontal Subtract. 4842// 4843// Forms: 4844// 4845// HSUBPD xmm xmm 4846// HSUBPD m128 xmm 4847// Construct and append a HSUBPD instruction to the active function. 4848func (c *Context) HSUBPD(mx, x operand.Op) { 4849 if inst, err := x86.HSUBPD(mx, x); err == nil { 4850 c.Instruction(inst) 4851 } else { 4852 c.adderror(err) 4853 } 4854} 4855 4856// HSUBPD: Packed Double-FP Horizontal Subtract. 4857// 4858// Forms: 4859// 4860// HSUBPD xmm xmm 4861// HSUBPD m128 xmm 4862// Construct and append a HSUBPD instruction to the active function. 4863// Operates on the global context. 4864func HSUBPD(mx, x operand.Op) { ctx.HSUBPD(mx, x) } 4865 4866// HSUBPS: Packed Single-FP Horizontal Subtract. 4867// 4868// Forms: 4869// 4870// HSUBPS xmm xmm 4871// HSUBPS m128 xmm 4872// Construct and append a HSUBPS instruction to the active function. 4873func (c *Context) HSUBPS(mx, x operand.Op) { 4874 if inst, err := x86.HSUBPS(mx, x); err == nil { 4875 c.Instruction(inst) 4876 } else { 4877 c.adderror(err) 4878 } 4879} 4880 4881// HSUBPS: Packed Single-FP Horizontal Subtract. 4882// 4883// Forms: 4884// 4885// HSUBPS xmm xmm 4886// HSUBPS m128 xmm 4887// Construct and append a HSUBPS instruction to the active function. 4888// Operates on the global context. 4889func HSUBPS(mx, x operand.Op) { ctx.HSUBPS(mx, x) } 4890 4891// IDIVB: Signed Divide. 4892// 4893// Forms: 4894// 4895// IDIVB r8 4896// IDIVB m8 4897// Construct and append a IDIVB instruction to the active function. 4898func (c *Context) IDIVB(mr operand.Op) { 4899 if inst, err := x86.IDIVB(mr); err == nil { 4900 c.Instruction(inst) 4901 } else { 4902 c.adderror(err) 4903 } 4904} 4905 4906// IDIVB: Signed Divide. 4907// 4908// Forms: 4909// 4910// IDIVB r8 4911// IDIVB m8 4912// Construct and append a IDIVB instruction to the active function. 4913// Operates on the global context. 4914func IDIVB(mr operand.Op) { ctx.IDIVB(mr) } 4915 4916// IDIVL: Signed Divide. 4917// 4918// Forms: 4919// 4920// IDIVL r32 4921// IDIVL m32 4922// Construct and append a IDIVL instruction to the active function. 4923func (c *Context) IDIVL(mr operand.Op) { 4924 if inst, err := x86.IDIVL(mr); err == nil { 4925 c.Instruction(inst) 4926 } else { 4927 c.adderror(err) 4928 } 4929} 4930 4931// IDIVL: Signed Divide. 4932// 4933// Forms: 4934// 4935// IDIVL r32 4936// IDIVL m32 4937// Construct and append a IDIVL instruction to the active function. 4938// Operates on the global context. 4939func IDIVL(mr operand.Op) { ctx.IDIVL(mr) } 4940 4941// IDIVQ: Signed Divide. 4942// 4943// Forms: 4944// 4945// IDIVQ r64 4946// IDIVQ m64 4947// Construct and append a IDIVQ instruction to the active function. 4948func (c *Context) IDIVQ(mr operand.Op) { 4949 if inst, err := x86.IDIVQ(mr); err == nil { 4950 c.Instruction(inst) 4951 } else { 4952 c.adderror(err) 4953 } 4954} 4955 4956// IDIVQ: Signed Divide. 4957// 4958// Forms: 4959// 4960// IDIVQ r64 4961// IDIVQ m64 4962// Construct and append a IDIVQ instruction to the active function. 4963// Operates on the global context. 4964func IDIVQ(mr operand.Op) { ctx.IDIVQ(mr) } 4965 4966// IDIVW: Signed Divide. 4967// 4968// Forms: 4969// 4970// IDIVW r16 4971// IDIVW m16 4972// Construct and append a IDIVW instruction to the active function. 4973func (c *Context) IDIVW(mr operand.Op) { 4974 if inst, err := x86.IDIVW(mr); err == nil { 4975 c.Instruction(inst) 4976 } else { 4977 c.adderror(err) 4978 } 4979} 4980 4981// IDIVW: Signed Divide. 4982// 4983// Forms: 4984// 4985// IDIVW r16 4986// IDIVW m16 4987// Construct and append a IDIVW instruction to the active function. 4988// Operates on the global context. 4989func IDIVW(mr operand.Op) { ctx.IDIVW(mr) } 4990 4991// IMUL3L: Signed Multiply. 4992// 4993// Forms: 4994// 4995// IMUL3L imm8 r32 r32 4996// IMUL3L imm32 r32 r32 4997// IMUL3L imm8 m32 r32 4998// IMUL3L imm32 m32 r32 4999// Construct and append a IMUL3L instruction to the active function. 5000func (c *Context) IMUL3L(i, mr, r operand.Op) { 5001 if inst, err := x86.IMUL3L(i, mr, r); err == nil { 5002 c.Instruction(inst) 5003 } else { 5004 c.adderror(err) 5005 } 5006} 5007 5008// IMUL3L: Signed Multiply. 5009// 5010// Forms: 5011// 5012// IMUL3L imm8 r32 r32 5013// IMUL3L imm32 r32 r32 5014// IMUL3L imm8 m32 r32 5015// IMUL3L imm32 m32 r32 5016// Construct and append a IMUL3L instruction to the active function. 5017// Operates on the global context. 5018func IMUL3L(i, mr, r operand.Op) { ctx.IMUL3L(i, mr, r) } 5019 5020// IMUL3Q: Signed Multiply. 5021// 5022// Forms: 5023// 5024// IMUL3Q imm8 r64 r64 5025// IMUL3Q imm32 r64 r64 5026// IMUL3Q imm8 m64 r64 5027// IMUL3Q imm32 m64 r64 5028// Construct and append a IMUL3Q instruction to the active function. 5029func (c *Context) IMUL3Q(i, mr, r operand.Op) { 5030 if inst, err := x86.IMUL3Q(i, mr, r); err == nil { 5031 c.Instruction(inst) 5032 } else { 5033 c.adderror(err) 5034 } 5035} 5036 5037// IMUL3Q: Signed Multiply. 5038// 5039// Forms: 5040// 5041// IMUL3Q imm8 r64 r64 5042// IMUL3Q imm32 r64 r64 5043// IMUL3Q imm8 m64 r64 5044// IMUL3Q imm32 m64 r64 5045// Construct and append a IMUL3Q instruction to the active function. 5046// Operates on the global context. 5047func IMUL3Q(i, mr, r operand.Op) { ctx.IMUL3Q(i, mr, r) } 5048 5049// IMUL3W: Signed Multiply. 5050// 5051// Forms: 5052// 5053// IMUL3W imm8 r16 r16 5054// IMUL3W imm16 r16 r16 5055// IMUL3W imm8 m16 r16 5056// IMUL3W imm16 m16 r16 5057// Construct and append a IMUL3W instruction to the active function. 5058func (c *Context) IMUL3W(i, mr, r operand.Op) { 5059 if inst, err := x86.IMUL3W(i, mr, r); err == nil { 5060 c.Instruction(inst) 5061 } else { 5062 c.adderror(err) 5063 } 5064} 5065 5066// IMUL3W: Signed Multiply. 5067// 5068// Forms: 5069// 5070// IMUL3W imm8 r16 r16 5071// IMUL3W imm16 r16 r16 5072// IMUL3W imm8 m16 r16 5073// IMUL3W imm16 m16 r16 5074// Construct and append a IMUL3W instruction to the active function. 5075// Operates on the global context. 5076func IMUL3W(i, mr, r operand.Op) { ctx.IMUL3W(i, mr, r) } 5077 5078// IMULB: Signed Multiply. 5079// 5080// Forms: 5081// 5082// IMULB r8 5083// IMULB m8 5084// Construct and append a IMULB instruction to the active function. 5085func (c *Context) IMULB(mr operand.Op) { 5086 if inst, err := x86.IMULB(mr); err == nil { 5087 c.Instruction(inst) 5088 } else { 5089 c.adderror(err) 5090 } 5091} 5092 5093// IMULB: Signed Multiply. 5094// 5095// Forms: 5096// 5097// IMULB r8 5098// IMULB m8 5099// Construct and append a IMULB instruction to the active function. 5100// Operates on the global context. 5101func IMULB(mr operand.Op) { ctx.IMULB(mr) } 5102 5103// IMULL: Signed Multiply. 5104// 5105// Forms: 5106// 5107// IMULL r32 5108// IMULL m32 5109// IMULL r32 r32 5110// IMULL m32 r32 5111// Construct and append a IMULL instruction to the active function. 5112func (c *Context) IMULL(ops ...operand.Op) { 5113 if inst, err := x86.IMULL(ops...); err == nil { 5114 c.Instruction(inst) 5115 } else { 5116 c.adderror(err) 5117 } 5118} 5119 5120// IMULL: Signed Multiply. 5121// 5122// Forms: 5123// 5124// IMULL r32 5125// IMULL m32 5126// IMULL r32 r32 5127// IMULL m32 r32 5128// Construct and append a IMULL instruction to the active function. 5129// Operates on the global context. 5130func IMULL(ops ...operand.Op) { ctx.IMULL(ops...) } 5131 5132// IMULQ: Signed Multiply. 5133// 5134// Forms: 5135// 5136// IMULQ r64 5137// IMULQ m64 5138// IMULQ r64 r64 5139// IMULQ m64 r64 5140// Construct and append a IMULQ instruction to the active function. 5141func (c *Context) IMULQ(ops ...operand.Op) { 5142 if inst, err := x86.IMULQ(ops...); err == nil { 5143 c.Instruction(inst) 5144 } else { 5145 c.adderror(err) 5146 } 5147} 5148 5149// IMULQ: Signed Multiply. 5150// 5151// Forms: 5152// 5153// IMULQ r64 5154// IMULQ m64 5155// IMULQ r64 r64 5156// IMULQ m64 r64 5157// Construct and append a IMULQ instruction to the active function. 5158// Operates on the global context. 5159func IMULQ(ops ...operand.Op) { ctx.IMULQ(ops...) } 5160 5161// IMULW: Signed Multiply. 5162// 5163// Forms: 5164// 5165// IMULW r16 5166// IMULW m16 5167// IMULW r16 r16 5168// IMULW m16 r16 5169// Construct and append a IMULW instruction to the active function. 5170func (c *Context) IMULW(ops ...operand.Op) { 5171 if inst, err := x86.IMULW(ops...); err == nil { 5172 c.Instruction(inst) 5173 } else { 5174 c.adderror(err) 5175 } 5176} 5177 5178// IMULW: Signed Multiply. 5179// 5180// Forms: 5181// 5182// IMULW r16 5183// IMULW m16 5184// IMULW r16 r16 5185// IMULW m16 r16 5186// Construct and append a IMULW instruction to the active function. 5187// Operates on the global context. 5188func IMULW(ops ...operand.Op) { ctx.IMULW(ops...) } 5189 5190// INCB: Increment by 1. 5191// 5192// Forms: 5193// 5194// INCB r8 5195// INCB m8 5196// Construct and append a INCB instruction to the active function. 5197func (c *Context) INCB(mr operand.Op) { 5198 if inst, err := x86.INCB(mr); err == nil { 5199 c.Instruction(inst) 5200 } else { 5201 c.adderror(err) 5202 } 5203} 5204 5205// INCB: Increment by 1. 5206// 5207// Forms: 5208// 5209// INCB r8 5210// INCB m8 5211// Construct and append a INCB instruction to the active function. 5212// Operates on the global context. 5213func INCB(mr operand.Op) { ctx.INCB(mr) } 5214 5215// INCL: Increment by 1. 5216// 5217// Forms: 5218// 5219// INCL r32 5220// INCL m32 5221// Construct and append a INCL instruction to the active function. 5222func (c *Context) INCL(mr operand.Op) { 5223 if inst, err := x86.INCL(mr); err == nil { 5224 c.Instruction(inst) 5225 } else { 5226 c.adderror(err) 5227 } 5228} 5229 5230// INCL: Increment by 1. 5231// 5232// Forms: 5233// 5234// INCL r32 5235// INCL m32 5236// Construct and append a INCL instruction to the active function. 5237// Operates on the global context. 5238func INCL(mr operand.Op) { ctx.INCL(mr) } 5239 5240// INCQ: Increment by 1. 5241// 5242// Forms: 5243// 5244// INCQ r64 5245// INCQ m64 5246// Construct and append a INCQ instruction to the active function. 5247func (c *Context) INCQ(mr operand.Op) { 5248 if inst, err := x86.INCQ(mr); err == nil { 5249 c.Instruction(inst) 5250 } else { 5251 c.adderror(err) 5252 } 5253} 5254 5255// INCQ: Increment by 1. 5256// 5257// Forms: 5258// 5259// INCQ r64 5260// INCQ m64 5261// Construct and append a INCQ instruction to the active function. 5262// Operates on the global context. 5263func INCQ(mr operand.Op) { ctx.INCQ(mr) } 5264 5265// INCW: Increment by 1. 5266// 5267// Forms: 5268// 5269// INCW r16 5270// INCW m16 5271// Construct and append a INCW instruction to the active function. 5272func (c *Context) INCW(mr operand.Op) { 5273 if inst, err := x86.INCW(mr); err == nil { 5274 c.Instruction(inst) 5275 } else { 5276 c.adderror(err) 5277 } 5278} 5279 5280// INCW: Increment by 1. 5281// 5282// Forms: 5283// 5284// INCW r16 5285// INCW m16 5286// Construct and append a INCW instruction to the active function. 5287// Operates on the global context. 5288func INCW(mr operand.Op) { ctx.INCW(mr) } 5289 5290// INSERTPS: Insert Packed Single Precision Floating-Point Value. 5291// 5292// Forms: 5293// 5294// INSERTPS imm8 xmm xmm 5295// INSERTPS imm8 m32 xmm 5296// Construct and append a INSERTPS instruction to the active function. 5297func (c *Context) INSERTPS(i, mx, x operand.Op) { 5298 if inst, err := x86.INSERTPS(i, mx, x); err == nil { 5299 c.Instruction(inst) 5300 } else { 5301 c.adderror(err) 5302 } 5303} 5304 5305// INSERTPS: Insert Packed Single Precision Floating-Point Value. 5306// 5307// Forms: 5308// 5309// INSERTPS imm8 xmm xmm 5310// INSERTPS imm8 m32 xmm 5311// Construct and append a INSERTPS instruction to the active function. 5312// Operates on the global context. 5313func INSERTPS(i, mx, x operand.Op) { ctx.INSERTPS(i, mx, x) } 5314 5315// INT: Call to Interrupt Procedure. 5316// 5317// Forms: 5318// 5319// INT 3 5320// INT imm8 5321// Construct and append a INT instruction to the active function. 5322func (c *Context) INT(i operand.Op) { 5323 if inst, err := x86.INT(i); err == nil { 5324 c.Instruction(inst) 5325 } else { 5326 c.adderror(err) 5327 } 5328} 5329 5330// INT: Call to Interrupt Procedure. 5331// 5332// Forms: 5333// 5334// INT 3 5335// INT imm8 5336// Construct and append a INT instruction to the active function. 5337// Operates on the global context. 5338func INT(i operand.Op) { ctx.INT(i) } 5339 5340// JA: Jump if above (CF == 0 and ZF == 0). 5341// 5342// Forms: 5343// 5344// JA rel8 5345// JA rel32 5346// Construct and append a JA instruction to the active function. 5347func (c *Context) JA(r operand.Op) { 5348 if inst, err := x86.JA(r); err == nil { 5349 c.Instruction(inst) 5350 } else { 5351 c.adderror(err) 5352 } 5353} 5354 5355// JA: Jump if above (CF == 0 and ZF == 0). 5356// 5357// Forms: 5358// 5359// JA rel8 5360// JA rel32 5361// Construct and append a JA instruction to the active function. 5362// Operates on the global context. 5363func JA(r operand.Op) { ctx.JA(r) } 5364 5365// JAE: Jump if above or equal (CF == 0). 5366// 5367// Forms: 5368// 5369// JAE rel8 5370// JAE rel32 5371// Construct and append a JAE instruction to the active function. 5372func (c *Context) JAE(r operand.Op) { 5373 if inst, err := x86.JAE(r); err == nil { 5374 c.Instruction(inst) 5375 } else { 5376 c.adderror(err) 5377 } 5378} 5379 5380// JAE: Jump if above or equal (CF == 0). 5381// 5382// Forms: 5383// 5384// JAE rel8 5385// JAE rel32 5386// Construct and append a JAE instruction to the active function. 5387// Operates on the global context. 5388func JAE(r operand.Op) { ctx.JAE(r) } 5389 5390// JB: Jump if below (CF == 1). 5391// 5392// Forms: 5393// 5394// JB rel8 5395// JB rel32 5396// Construct and append a JB instruction to the active function. 5397func (c *Context) JB(r operand.Op) { 5398 if inst, err := x86.JB(r); err == nil { 5399 c.Instruction(inst) 5400 } else { 5401 c.adderror(err) 5402 } 5403} 5404 5405// JB: Jump if below (CF == 1). 5406// 5407// Forms: 5408// 5409// JB rel8 5410// JB rel32 5411// Construct and append a JB instruction to the active function. 5412// Operates on the global context. 5413func JB(r operand.Op) { ctx.JB(r) } 5414 5415// JBE: Jump if below or equal (CF == 1 or ZF == 1). 5416// 5417// Forms: 5418// 5419// JBE rel8 5420// JBE rel32 5421// Construct and append a JBE instruction to the active function. 5422func (c *Context) JBE(r operand.Op) { 5423 if inst, err := x86.JBE(r); err == nil { 5424 c.Instruction(inst) 5425 } else { 5426 c.adderror(err) 5427 } 5428} 5429 5430// JBE: Jump if below or equal (CF == 1 or ZF == 1). 5431// 5432// Forms: 5433// 5434// JBE rel8 5435// JBE rel32 5436// Construct and append a JBE instruction to the active function. 5437// Operates on the global context. 5438func JBE(r operand.Op) { ctx.JBE(r) } 5439 5440// JC: Jump if below (CF == 1). 5441// 5442// Forms: 5443// 5444// JC rel8 5445// JC rel32 5446// Construct and append a JC instruction to the active function. 5447func (c *Context) JC(r operand.Op) { 5448 if inst, err := x86.JC(r); err == nil { 5449 c.Instruction(inst) 5450 } else { 5451 c.adderror(err) 5452 } 5453} 5454 5455// JC: Jump if below (CF == 1). 5456// 5457// Forms: 5458// 5459// JC rel8 5460// JC rel32 5461// Construct and append a JC instruction to the active function. 5462// Operates on the global context. 5463func JC(r operand.Op) { ctx.JC(r) } 5464 5465// JCC: Jump if above or equal (CF == 0). 5466// 5467// Forms: 5468// 5469// JCC rel8 5470// JCC rel32 5471// Construct and append a JCC instruction to the active function. 5472func (c *Context) JCC(r operand.Op) { 5473 if inst, err := x86.JCC(r); err == nil { 5474 c.Instruction(inst) 5475 } else { 5476 c.adderror(err) 5477 } 5478} 5479 5480// JCC: Jump if above or equal (CF == 0). 5481// 5482// Forms: 5483// 5484// JCC rel8 5485// JCC rel32 5486// Construct and append a JCC instruction to the active function. 5487// Operates on the global context. 5488func JCC(r operand.Op) { ctx.JCC(r) } 5489 5490// JCS: Jump if below (CF == 1). 5491// 5492// Forms: 5493// 5494// JCS rel8 5495// JCS rel32 5496// Construct and append a JCS instruction to the active function. 5497func (c *Context) JCS(r operand.Op) { 5498 if inst, err := x86.JCS(r); err == nil { 5499 c.Instruction(inst) 5500 } else { 5501 c.adderror(err) 5502 } 5503} 5504 5505// JCS: Jump if below (CF == 1). 5506// 5507// Forms: 5508// 5509// JCS rel8 5510// JCS rel32 5511// Construct and append a JCS instruction to the active function. 5512// Operates on the global context. 5513func JCS(r operand.Op) { ctx.JCS(r) } 5514 5515// JCXZL: Jump if ECX register is 0. 5516// 5517// Forms: 5518// 5519// JCXZL rel8 5520// Construct and append a JCXZL instruction to the active function. 5521func (c *Context) JCXZL(r operand.Op) { 5522 if inst, err := x86.JCXZL(r); err == nil { 5523 c.Instruction(inst) 5524 } else { 5525 c.adderror(err) 5526 } 5527} 5528 5529// JCXZL: Jump if ECX register is 0. 5530// 5531// Forms: 5532// 5533// JCXZL rel8 5534// Construct and append a JCXZL instruction to the active function. 5535// Operates on the global context. 5536func JCXZL(r operand.Op) { ctx.JCXZL(r) } 5537 5538// JCXZQ: Jump if RCX register is 0. 5539// 5540// Forms: 5541// 5542// JCXZQ rel8 5543// Construct and append a JCXZQ instruction to the active function. 5544func (c *Context) JCXZQ(r operand.Op) { 5545 if inst, err := x86.JCXZQ(r); err == nil { 5546 c.Instruction(inst) 5547 } else { 5548 c.adderror(err) 5549 } 5550} 5551 5552// JCXZQ: Jump if RCX register is 0. 5553// 5554// Forms: 5555// 5556// JCXZQ rel8 5557// Construct and append a JCXZQ instruction to the active function. 5558// Operates on the global context. 5559func JCXZQ(r operand.Op) { ctx.JCXZQ(r) } 5560 5561// JE: Jump if equal (ZF == 1). 5562// 5563// Forms: 5564// 5565// JE rel8 5566// JE rel32 5567// Construct and append a JE instruction to the active function. 5568func (c *Context) JE(r operand.Op) { 5569 if inst, err := x86.JE(r); err == nil { 5570 c.Instruction(inst) 5571 } else { 5572 c.adderror(err) 5573 } 5574} 5575 5576// JE: Jump if equal (ZF == 1). 5577// 5578// Forms: 5579// 5580// JE rel8 5581// JE rel32 5582// Construct and append a JE instruction to the active function. 5583// Operates on the global context. 5584func JE(r operand.Op) { ctx.JE(r) } 5585 5586// JEQ: Jump if equal (ZF == 1). 5587// 5588// Forms: 5589// 5590// JEQ rel8 5591// JEQ rel32 5592// Construct and append a JEQ instruction to the active function. 5593func (c *Context) JEQ(r operand.Op) { 5594 if inst, err := x86.JEQ(r); err == nil { 5595 c.Instruction(inst) 5596 } else { 5597 c.adderror(err) 5598 } 5599} 5600 5601// JEQ: Jump if equal (ZF == 1). 5602// 5603// Forms: 5604// 5605// JEQ rel8 5606// JEQ rel32 5607// Construct and append a JEQ instruction to the active function. 5608// Operates on the global context. 5609func JEQ(r operand.Op) { ctx.JEQ(r) } 5610 5611// JG: Jump if greater (ZF == 0 and SF == OF). 5612// 5613// Forms: 5614// 5615// JG rel8 5616// JG rel32 5617// Construct and append a JG instruction to the active function. 5618func (c *Context) JG(r operand.Op) { 5619 if inst, err := x86.JG(r); err == nil { 5620 c.Instruction(inst) 5621 } else { 5622 c.adderror(err) 5623 } 5624} 5625 5626// JG: Jump if greater (ZF == 0 and SF == OF). 5627// 5628// Forms: 5629// 5630// JG rel8 5631// JG rel32 5632// Construct and append a JG instruction to the active function. 5633// Operates on the global context. 5634func JG(r operand.Op) { ctx.JG(r) } 5635 5636// JGE: Jump if greater or equal (SF == OF). 5637// 5638// Forms: 5639// 5640// JGE rel8 5641// JGE rel32 5642// Construct and append a JGE instruction to the active function. 5643func (c *Context) JGE(r operand.Op) { 5644 if inst, err := x86.JGE(r); err == nil { 5645 c.Instruction(inst) 5646 } else { 5647 c.adderror(err) 5648 } 5649} 5650 5651// JGE: Jump if greater or equal (SF == OF). 5652// 5653// Forms: 5654// 5655// JGE rel8 5656// JGE rel32 5657// Construct and append a JGE instruction to the active function. 5658// Operates on the global context. 5659func JGE(r operand.Op) { ctx.JGE(r) } 5660 5661// JGT: Jump if greater (ZF == 0 and SF == OF). 5662// 5663// Forms: 5664// 5665// JGT rel8 5666// JGT rel32 5667// Construct and append a JGT instruction to the active function. 5668func (c *Context) JGT(r operand.Op) { 5669 if inst, err := x86.JGT(r); err == nil { 5670 c.Instruction(inst) 5671 } else { 5672 c.adderror(err) 5673 } 5674} 5675 5676// JGT: Jump if greater (ZF == 0 and SF == OF). 5677// 5678// Forms: 5679// 5680// JGT rel8 5681// JGT rel32 5682// Construct and append a JGT instruction to the active function. 5683// Operates on the global context. 5684func JGT(r operand.Op) { ctx.JGT(r) } 5685 5686// JHI: Jump if above (CF == 0 and ZF == 0). 5687// 5688// Forms: 5689// 5690// JHI rel8 5691// JHI rel32 5692// Construct and append a JHI instruction to the active function. 5693func (c *Context) JHI(r operand.Op) { 5694 if inst, err := x86.JHI(r); err == nil { 5695 c.Instruction(inst) 5696 } else { 5697 c.adderror(err) 5698 } 5699} 5700 5701// JHI: Jump if above (CF == 0 and ZF == 0). 5702// 5703// Forms: 5704// 5705// JHI rel8 5706// JHI rel32 5707// Construct and append a JHI instruction to the active function. 5708// Operates on the global context. 5709func JHI(r operand.Op) { ctx.JHI(r) } 5710 5711// JHS: Jump if above or equal (CF == 0). 5712// 5713// Forms: 5714// 5715// JHS rel8 5716// JHS rel32 5717// Construct and append a JHS instruction to the active function. 5718func (c *Context) JHS(r operand.Op) { 5719 if inst, err := x86.JHS(r); err == nil { 5720 c.Instruction(inst) 5721 } else { 5722 c.adderror(err) 5723 } 5724} 5725 5726// JHS: Jump if above or equal (CF == 0). 5727// 5728// Forms: 5729// 5730// JHS rel8 5731// JHS rel32 5732// Construct and append a JHS instruction to the active function. 5733// Operates on the global context. 5734func JHS(r operand.Op) { ctx.JHS(r) } 5735 5736// JL: Jump if less (SF != OF). 5737// 5738// Forms: 5739// 5740// JL rel8 5741// JL rel32 5742// Construct and append a JL instruction to the active function. 5743func (c *Context) JL(r operand.Op) { 5744 if inst, err := x86.JL(r); err == nil { 5745 c.Instruction(inst) 5746 } else { 5747 c.adderror(err) 5748 } 5749} 5750 5751// JL: Jump if less (SF != OF). 5752// 5753// Forms: 5754// 5755// JL rel8 5756// JL rel32 5757// Construct and append a JL instruction to the active function. 5758// Operates on the global context. 5759func JL(r operand.Op) { ctx.JL(r) } 5760 5761// JLE: Jump if less or equal (ZF == 1 or SF != OF). 5762// 5763// Forms: 5764// 5765// JLE rel8 5766// JLE rel32 5767// Construct and append a JLE instruction to the active function. 5768func (c *Context) JLE(r operand.Op) { 5769 if inst, err := x86.JLE(r); err == nil { 5770 c.Instruction(inst) 5771 } else { 5772 c.adderror(err) 5773 } 5774} 5775 5776// JLE: Jump if less or equal (ZF == 1 or SF != OF). 5777// 5778// Forms: 5779// 5780// JLE rel8 5781// JLE rel32 5782// Construct and append a JLE instruction to the active function. 5783// Operates on the global context. 5784func JLE(r operand.Op) { ctx.JLE(r) } 5785 5786// JLO: Jump if below (CF == 1). 5787// 5788// Forms: 5789// 5790// JLO rel8 5791// JLO rel32 5792// Construct and append a JLO instruction to the active function. 5793func (c *Context) JLO(r operand.Op) { 5794 if inst, err := x86.JLO(r); err == nil { 5795 c.Instruction(inst) 5796 } else { 5797 c.adderror(err) 5798 } 5799} 5800 5801// JLO: Jump if below (CF == 1). 5802// 5803// Forms: 5804// 5805// JLO rel8 5806// JLO rel32 5807// Construct and append a JLO instruction to the active function. 5808// Operates on the global context. 5809func JLO(r operand.Op) { ctx.JLO(r) } 5810 5811// JLS: Jump if below or equal (CF == 1 or ZF == 1). 5812// 5813// Forms: 5814// 5815// JLS rel8 5816// JLS rel32 5817// Construct and append a JLS instruction to the active function. 5818func (c *Context) JLS(r operand.Op) { 5819 if inst, err := x86.JLS(r); err == nil { 5820 c.Instruction(inst) 5821 } else { 5822 c.adderror(err) 5823 } 5824} 5825 5826// JLS: Jump if below or equal (CF == 1 or ZF == 1). 5827// 5828// Forms: 5829// 5830// JLS rel8 5831// JLS rel32 5832// Construct and append a JLS instruction to the active function. 5833// Operates on the global context. 5834func JLS(r operand.Op) { ctx.JLS(r) } 5835 5836// JLT: Jump if less (SF != OF). 5837// 5838// Forms: 5839// 5840// JLT rel8 5841// JLT rel32 5842// Construct and append a JLT instruction to the active function. 5843func (c *Context) JLT(r operand.Op) { 5844 if inst, err := x86.JLT(r); err == nil { 5845 c.Instruction(inst) 5846 } else { 5847 c.adderror(err) 5848 } 5849} 5850 5851// JLT: Jump if less (SF != OF). 5852// 5853// Forms: 5854// 5855// JLT rel8 5856// JLT rel32 5857// Construct and append a JLT instruction to the active function. 5858// Operates on the global context. 5859func JLT(r operand.Op) { ctx.JLT(r) } 5860 5861// JMI: Jump if sign (SF == 1). 5862// 5863// Forms: 5864// 5865// JMI rel8 5866// JMI rel32 5867// Construct and append a JMI instruction to the active function. 5868func (c *Context) JMI(r operand.Op) { 5869 if inst, err := x86.JMI(r); err == nil { 5870 c.Instruction(inst) 5871 } else { 5872 c.adderror(err) 5873 } 5874} 5875 5876// JMI: Jump if sign (SF == 1). 5877// 5878// Forms: 5879// 5880// JMI rel8 5881// JMI rel32 5882// Construct and append a JMI instruction to the active function. 5883// Operates on the global context. 5884func JMI(r operand.Op) { ctx.JMI(r) } 5885 5886// JMP: Jump Unconditionally. 5887// 5888// Forms: 5889// 5890// JMP rel8 5891// JMP rel32 5892// JMP r64 5893// JMP m64 5894// Construct and append a JMP instruction to the active function. 5895func (c *Context) JMP(mr operand.Op) { 5896 if inst, err := x86.JMP(mr); err == nil { 5897 c.Instruction(inst) 5898 } else { 5899 c.adderror(err) 5900 } 5901} 5902 5903// JMP: Jump Unconditionally. 5904// 5905// Forms: 5906// 5907// JMP rel8 5908// JMP rel32 5909// JMP r64 5910// JMP m64 5911// Construct and append a JMP instruction to the active function. 5912// Operates on the global context. 5913func JMP(mr operand.Op) { ctx.JMP(mr) } 5914 5915// JNA: Jump if below or equal (CF == 1 or ZF == 1). 5916// 5917// Forms: 5918// 5919// JNA rel8 5920// JNA rel32 5921// Construct and append a JNA instruction to the active function. 5922func (c *Context) JNA(r operand.Op) { 5923 if inst, err := x86.JNA(r); err == nil { 5924 c.Instruction(inst) 5925 } else { 5926 c.adderror(err) 5927 } 5928} 5929 5930// JNA: Jump if below or equal (CF == 1 or ZF == 1). 5931// 5932// Forms: 5933// 5934// JNA rel8 5935// JNA rel32 5936// Construct and append a JNA instruction to the active function. 5937// Operates on the global context. 5938func JNA(r operand.Op) { ctx.JNA(r) } 5939 5940// JNAE: Jump if below (CF == 1). 5941// 5942// Forms: 5943// 5944// JNAE rel8 5945// JNAE rel32 5946// Construct and append a JNAE instruction to the active function. 5947func (c *Context) JNAE(r operand.Op) { 5948 if inst, err := x86.JNAE(r); err == nil { 5949 c.Instruction(inst) 5950 } else { 5951 c.adderror(err) 5952 } 5953} 5954 5955// JNAE: Jump if below (CF == 1). 5956// 5957// Forms: 5958// 5959// JNAE rel8 5960// JNAE rel32 5961// Construct and append a JNAE instruction to the active function. 5962// Operates on the global context. 5963func JNAE(r operand.Op) { ctx.JNAE(r) } 5964 5965// JNB: Jump if above or equal (CF == 0). 5966// 5967// Forms: 5968// 5969// JNB rel8 5970// JNB rel32 5971// Construct and append a JNB instruction to the active function. 5972func (c *Context) JNB(r operand.Op) { 5973 if inst, err := x86.JNB(r); err == nil { 5974 c.Instruction(inst) 5975 } else { 5976 c.adderror(err) 5977 } 5978} 5979 5980// JNB: Jump if above or equal (CF == 0). 5981// 5982// Forms: 5983// 5984// JNB rel8 5985// JNB rel32 5986// Construct and append a JNB instruction to the active function. 5987// Operates on the global context. 5988func JNB(r operand.Op) { ctx.JNB(r) } 5989 5990// JNBE: Jump if above (CF == 0 and ZF == 0). 5991// 5992// Forms: 5993// 5994// JNBE rel8 5995// JNBE rel32 5996// Construct and append a JNBE instruction to the active function. 5997func (c *Context) JNBE(r operand.Op) { 5998 if inst, err := x86.JNBE(r); err == nil { 5999 c.Instruction(inst) 6000 } else { 6001 c.adderror(err) 6002 } 6003} 6004 6005// JNBE: Jump if above (CF == 0 and ZF == 0). 6006// 6007// Forms: 6008// 6009// JNBE rel8 6010// JNBE rel32 6011// Construct and append a JNBE instruction to the active function. 6012// Operates on the global context. 6013func JNBE(r operand.Op) { ctx.JNBE(r) } 6014 6015// JNC: Jump if above or equal (CF == 0). 6016// 6017// Forms: 6018// 6019// JNC rel8 6020// JNC rel32 6021// Construct and append a JNC instruction to the active function. 6022func (c *Context) JNC(r operand.Op) { 6023 if inst, err := x86.JNC(r); err == nil { 6024 c.Instruction(inst) 6025 } else { 6026 c.adderror(err) 6027 } 6028} 6029 6030// JNC: Jump if above or equal (CF == 0). 6031// 6032// Forms: 6033// 6034// JNC rel8 6035// JNC rel32 6036// Construct and append a JNC instruction to the active function. 6037// Operates on the global context. 6038func JNC(r operand.Op) { ctx.JNC(r) } 6039 6040// JNE: Jump if not equal (ZF == 0). 6041// 6042// Forms: 6043// 6044// JNE rel8 6045// JNE rel32 6046// Construct and append a JNE instruction to the active function. 6047func (c *Context) JNE(r operand.Op) { 6048 if inst, err := x86.JNE(r); err == nil { 6049 c.Instruction(inst) 6050 } else { 6051 c.adderror(err) 6052 } 6053} 6054 6055// JNE: Jump if not equal (ZF == 0). 6056// 6057// Forms: 6058// 6059// JNE rel8 6060// JNE rel32 6061// Construct and append a JNE instruction to the active function. 6062// Operates on the global context. 6063func JNE(r operand.Op) { ctx.JNE(r) } 6064 6065// JNG: Jump if less or equal (ZF == 1 or SF != OF). 6066// 6067// Forms: 6068// 6069// JNG rel8 6070// JNG rel32 6071// Construct and append a JNG instruction to the active function. 6072func (c *Context) JNG(r operand.Op) { 6073 if inst, err := x86.JNG(r); err == nil { 6074 c.Instruction(inst) 6075 } else { 6076 c.adderror(err) 6077 } 6078} 6079 6080// JNG: Jump if less or equal (ZF == 1 or SF != OF). 6081// 6082// Forms: 6083// 6084// JNG rel8 6085// JNG rel32 6086// Construct and append a JNG instruction to the active function. 6087// Operates on the global context. 6088func JNG(r operand.Op) { ctx.JNG(r) } 6089 6090// JNGE: Jump if less (SF != OF). 6091// 6092// Forms: 6093// 6094// JNGE rel8 6095// JNGE rel32 6096// Construct and append a JNGE instruction to the active function. 6097func (c *Context) JNGE(r operand.Op) { 6098 if inst, err := x86.JNGE(r); err == nil { 6099 c.Instruction(inst) 6100 } else { 6101 c.adderror(err) 6102 } 6103} 6104 6105// JNGE: Jump if less (SF != OF). 6106// 6107// Forms: 6108// 6109// JNGE rel8 6110// JNGE rel32 6111// Construct and append a JNGE instruction to the active function. 6112// Operates on the global context. 6113func JNGE(r operand.Op) { ctx.JNGE(r) } 6114 6115// JNL: Jump if greater or equal (SF == OF). 6116// 6117// Forms: 6118// 6119// JNL rel8 6120// JNL rel32 6121// Construct and append a JNL instruction to the active function. 6122func (c *Context) JNL(r operand.Op) { 6123 if inst, err := x86.JNL(r); err == nil { 6124 c.Instruction(inst) 6125 } else { 6126 c.adderror(err) 6127 } 6128} 6129 6130// JNL: Jump if greater or equal (SF == OF). 6131// 6132// Forms: 6133// 6134// JNL rel8 6135// JNL rel32 6136// Construct and append a JNL instruction to the active function. 6137// Operates on the global context. 6138func JNL(r operand.Op) { ctx.JNL(r) } 6139 6140// JNLE: Jump if greater (ZF == 0 and SF == OF). 6141// 6142// Forms: 6143// 6144// JNLE rel8 6145// JNLE rel32 6146// Construct and append a JNLE instruction to the active function. 6147func (c *Context) JNLE(r operand.Op) { 6148 if inst, err := x86.JNLE(r); err == nil { 6149 c.Instruction(inst) 6150 } else { 6151 c.adderror(err) 6152 } 6153} 6154 6155// JNLE: Jump if greater (ZF == 0 and SF == OF). 6156// 6157// Forms: 6158// 6159// JNLE rel8 6160// JNLE rel32 6161// Construct and append a JNLE instruction to the active function. 6162// Operates on the global context. 6163func JNLE(r operand.Op) { ctx.JNLE(r) } 6164 6165// JNO: Jump if not overflow (OF == 0). 6166// 6167// Forms: 6168// 6169// JNO rel8 6170// JNO rel32 6171// Construct and append a JNO instruction to the active function. 6172func (c *Context) JNO(r operand.Op) { 6173 if inst, err := x86.JNO(r); err == nil { 6174 c.Instruction(inst) 6175 } else { 6176 c.adderror(err) 6177 } 6178} 6179 6180// JNO: Jump if not overflow (OF == 0). 6181// 6182// Forms: 6183// 6184// JNO rel8 6185// JNO rel32 6186// Construct and append a JNO instruction to the active function. 6187// Operates on the global context. 6188func JNO(r operand.Op) { ctx.JNO(r) } 6189 6190// JNP: Jump if not parity (PF == 0). 6191// 6192// Forms: 6193// 6194// JNP rel8 6195// JNP rel32 6196// Construct and append a JNP instruction to the active function. 6197func (c *Context) JNP(r operand.Op) { 6198 if inst, err := x86.JNP(r); err == nil { 6199 c.Instruction(inst) 6200 } else { 6201 c.adderror(err) 6202 } 6203} 6204 6205// JNP: Jump if not parity (PF == 0). 6206// 6207// Forms: 6208// 6209// JNP rel8 6210// JNP rel32 6211// Construct and append a JNP instruction to the active function. 6212// Operates on the global context. 6213func JNP(r operand.Op) { ctx.JNP(r) } 6214 6215// JNS: Jump if not sign (SF == 0). 6216// 6217// Forms: 6218// 6219// JNS rel8 6220// JNS rel32 6221// Construct and append a JNS instruction to the active function. 6222func (c *Context) JNS(r operand.Op) { 6223 if inst, err := x86.JNS(r); err == nil { 6224 c.Instruction(inst) 6225 } else { 6226 c.adderror(err) 6227 } 6228} 6229 6230// JNS: Jump if not sign (SF == 0). 6231// 6232// Forms: 6233// 6234// JNS rel8 6235// JNS rel32 6236// Construct and append a JNS instruction to the active function. 6237// Operates on the global context. 6238func JNS(r operand.Op) { ctx.JNS(r) } 6239 6240// JNZ: Jump if not equal (ZF == 0). 6241// 6242// Forms: 6243// 6244// JNZ rel8 6245// JNZ rel32 6246// Construct and append a JNZ instruction to the active function. 6247func (c *Context) JNZ(r operand.Op) { 6248 if inst, err := x86.JNZ(r); err == nil { 6249 c.Instruction(inst) 6250 } else { 6251 c.adderror(err) 6252 } 6253} 6254 6255// JNZ: Jump if not equal (ZF == 0). 6256// 6257// Forms: 6258// 6259// JNZ rel8 6260// JNZ rel32 6261// Construct and append a JNZ instruction to the active function. 6262// Operates on the global context. 6263func JNZ(r operand.Op) { ctx.JNZ(r) } 6264 6265// JO: Jump if overflow (OF == 1). 6266// 6267// Forms: 6268// 6269// JO rel8 6270// JO rel32 6271// Construct and append a JO instruction to the active function. 6272func (c *Context) JO(r operand.Op) { 6273 if inst, err := x86.JO(r); err == nil { 6274 c.Instruction(inst) 6275 } else { 6276 c.adderror(err) 6277 } 6278} 6279 6280// JO: Jump if overflow (OF == 1). 6281// 6282// Forms: 6283// 6284// JO rel8 6285// JO rel32 6286// Construct and append a JO instruction to the active function. 6287// Operates on the global context. 6288func JO(r operand.Op) { ctx.JO(r) } 6289 6290// JOC: Jump if not overflow (OF == 0). 6291// 6292// Forms: 6293// 6294// JOC rel8 6295// JOC rel32 6296// Construct and append a JOC instruction to the active function. 6297func (c *Context) JOC(r operand.Op) { 6298 if inst, err := x86.JOC(r); err == nil { 6299 c.Instruction(inst) 6300 } else { 6301 c.adderror(err) 6302 } 6303} 6304 6305// JOC: Jump if not overflow (OF == 0). 6306// 6307// Forms: 6308// 6309// JOC rel8 6310// JOC rel32 6311// Construct and append a JOC instruction to the active function. 6312// Operates on the global context. 6313func JOC(r operand.Op) { ctx.JOC(r) } 6314 6315// JOS: Jump if overflow (OF == 1). 6316// 6317// Forms: 6318// 6319// JOS rel8 6320// JOS rel32 6321// Construct and append a JOS instruction to the active function. 6322func (c *Context) JOS(r operand.Op) { 6323 if inst, err := x86.JOS(r); err == nil { 6324 c.Instruction(inst) 6325 } else { 6326 c.adderror(err) 6327 } 6328} 6329 6330// JOS: Jump if overflow (OF == 1). 6331// 6332// Forms: 6333// 6334// JOS rel8 6335// JOS rel32 6336// Construct and append a JOS instruction to the active function. 6337// Operates on the global context. 6338func JOS(r operand.Op) { ctx.JOS(r) } 6339 6340// JP: Jump if parity (PF == 1). 6341// 6342// Forms: 6343// 6344// JP rel8 6345// JP rel32 6346// Construct and append a JP instruction to the active function. 6347func (c *Context) JP(r operand.Op) { 6348 if inst, err := x86.JP(r); err == nil { 6349 c.Instruction(inst) 6350 } else { 6351 c.adderror(err) 6352 } 6353} 6354 6355// JP: Jump if parity (PF == 1). 6356// 6357// Forms: 6358// 6359// JP rel8 6360// JP rel32 6361// Construct and append a JP instruction to the active function. 6362// Operates on the global context. 6363func JP(r operand.Op) { ctx.JP(r) } 6364 6365// JPC: Jump if not parity (PF == 0). 6366// 6367// Forms: 6368// 6369// JPC rel8 6370// JPC rel32 6371// Construct and append a JPC instruction to the active function. 6372func (c *Context) JPC(r operand.Op) { 6373 if inst, err := x86.JPC(r); err == nil { 6374 c.Instruction(inst) 6375 } else { 6376 c.adderror(err) 6377 } 6378} 6379 6380// JPC: Jump if not parity (PF == 0). 6381// 6382// Forms: 6383// 6384// JPC rel8 6385// JPC rel32 6386// Construct and append a JPC instruction to the active function. 6387// Operates on the global context. 6388func JPC(r operand.Op) { ctx.JPC(r) } 6389 6390// JPE: Jump if parity (PF == 1). 6391// 6392// Forms: 6393// 6394// JPE rel8 6395// JPE rel32 6396// Construct and append a JPE instruction to the active function. 6397func (c *Context) JPE(r operand.Op) { 6398 if inst, err := x86.JPE(r); err == nil { 6399 c.Instruction(inst) 6400 } else { 6401 c.adderror(err) 6402 } 6403} 6404 6405// JPE: Jump if parity (PF == 1). 6406// 6407// Forms: 6408// 6409// JPE rel8 6410// JPE rel32 6411// Construct and append a JPE instruction to the active function. 6412// Operates on the global context. 6413func JPE(r operand.Op) { ctx.JPE(r) } 6414 6415// JPL: Jump if not sign (SF == 0). 6416// 6417// Forms: 6418// 6419// JPL rel8 6420// JPL rel32 6421// Construct and append a JPL instruction to the active function. 6422func (c *Context) JPL(r operand.Op) { 6423 if inst, err := x86.JPL(r); err == nil { 6424 c.Instruction(inst) 6425 } else { 6426 c.adderror(err) 6427 } 6428} 6429 6430// JPL: Jump if not sign (SF == 0). 6431// 6432// Forms: 6433// 6434// JPL rel8 6435// JPL rel32 6436// Construct and append a JPL instruction to the active function. 6437// Operates on the global context. 6438func JPL(r operand.Op) { ctx.JPL(r) } 6439 6440// JPO: Jump if not parity (PF == 0). 6441// 6442// Forms: 6443// 6444// JPO rel8 6445// JPO rel32 6446// Construct and append a JPO instruction to the active function. 6447func (c *Context) JPO(r operand.Op) { 6448 if inst, err := x86.JPO(r); err == nil { 6449 c.Instruction(inst) 6450 } else { 6451 c.adderror(err) 6452 } 6453} 6454 6455// JPO: Jump if not parity (PF == 0). 6456// 6457// Forms: 6458// 6459// JPO rel8 6460// JPO rel32 6461// Construct and append a JPO instruction to the active function. 6462// Operates on the global context. 6463func JPO(r operand.Op) { ctx.JPO(r) } 6464 6465// JPS: Jump if parity (PF == 1). 6466// 6467// Forms: 6468// 6469// JPS rel8 6470// JPS rel32 6471// Construct and append a JPS instruction to the active function. 6472func (c *Context) JPS(r operand.Op) { 6473 if inst, err := x86.JPS(r); err == nil { 6474 c.Instruction(inst) 6475 } else { 6476 c.adderror(err) 6477 } 6478} 6479 6480// JPS: Jump if parity (PF == 1). 6481// 6482// Forms: 6483// 6484// JPS rel8 6485// JPS rel32 6486// Construct and append a JPS instruction to the active function. 6487// Operates on the global context. 6488func JPS(r operand.Op) { ctx.JPS(r) } 6489 6490// JS: Jump if sign (SF == 1). 6491// 6492// Forms: 6493// 6494// JS rel8 6495// JS rel32 6496// Construct and append a JS instruction to the active function. 6497func (c *Context) JS(r operand.Op) { 6498 if inst, err := x86.JS(r); err == nil { 6499 c.Instruction(inst) 6500 } else { 6501 c.adderror(err) 6502 } 6503} 6504 6505// JS: Jump if sign (SF == 1). 6506// 6507// Forms: 6508// 6509// JS rel8 6510// JS rel32 6511// Construct and append a JS instruction to the active function. 6512// Operates on the global context. 6513func JS(r operand.Op) { ctx.JS(r) } 6514 6515// JZ: Jump if equal (ZF == 1). 6516// 6517// Forms: 6518// 6519// JZ rel8 6520// JZ rel32 6521// Construct and append a JZ instruction to the active function. 6522func (c *Context) JZ(r operand.Op) { 6523 if inst, err := x86.JZ(r); err == nil { 6524 c.Instruction(inst) 6525 } else { 6526 c.adderror(err) 6527 } 6528} 6529 6530// JZ: Jump if equal (ZF == 1). 6531// 6532// Forms: 6533// 6534// JZ rel8 6535// JZ rel32 6536// Construct and append a JZ instruction to the active function. 6537// Operates on the global context. 6538func JZ(r operand.Op) { ctx.JZ(r) } 6539 6540// LDDQU: Load Unaligned Integer 128 Bits. 6541// 6542// Forms: 6543// 6544// LDDQU m128 xmm 6545// Construct and append a LDDQU instruction to the active function. 6546func (c *Context) LDDQU(m, x operand.Op) { 6547 if inst, err := x86.LDDQU(m, x); err == nil { 6548 c.Instruction(inst) 6549 } else { 6550 c.adderror(err) 6551 } 6552} 6553 6554// LDDQU: Load Unaligned Integer 128 Bits. 6555// 6556// Forms: 6557// 6558// LDDQU m128 xmm 6559// Construct and append a LDDQU instruction to the active function. 6560// Operates on the global context. 6561func LDDQU(m, x operand.Op) { ctx.LDDQU(m, x) } 6562 6563// LDMXCSR: Load MXCSR Register. 6564// 6565// Forms: 6566// 6567// LDMXCSR m32 6568// Construct and append a LDMXCSR instruction to the active function. 6569func (c *Context) LDMXCSR(m operand.Op) { 6570 if inst, err := x86.LDMXCSR(m); err == nil { 6571 c.Instruction(inst) 6572 } else { 6573 c.adderror(err) 6574 } 6575} 6576 6577// LDMXCSR: Load MXCSR Register. 6578// 6579// Forms: 6580// 6581// LDMXCSR m32 6582// Construct and append a LDMXCSR instruction to the active function. 6583// Operates on the global context. 6584func LDMXCSR(m operand.Op) { ctx.LDMXCSR(m) } 6585 6586// LEAL: Load Effective Address. 6587// 6588// Forms: 6589// 6590// LEAL m r32 6591// Construct and append a LEAL instruction to the active function. 6592func (c *Context) LEAL(m, r operand.Op) { 6593 if inst, err := x86.LEAL(m, r); err == nil { 6594 c.Instruction(inst) 6595 } else { 6596 c.adderror(err) 6597 } 6598} 6599 6600// LEAL: Load Effective Address. 6601// 6602// Forms: 6603// 6604// LEAL m r32 6605// Construct and append a LEAL instruction to the active function. 6606// Operates on the global context. 6607func LEAL(m, r operand.Op) { ctx.LEAL(m, r) } 6608 6609// LEAQ: Load Effective Address. 6610// 6611// Forms: 6612// 6613// LEAQ m r64 6614// Construct and append a LEAQ instruction to the active function. 6615func (c *Context) LEAQ(m, r operand.Op) { 6616 if inst, err := x86.LEAQ(m, r); err == nil { 6617 c.Instruction(inst) 6618 } else { 6619 c.adderror(err) 6620 } 6621} 6622 6623// LEAQ: Load Effective Address. 6624// 6625// Forms: 6626// 6627// LEAQ m r64 6628// Construct and append a LEAQ instruction to the active function. 6629// Operates on the global context. 6630func LEAQ(m, r operand.Op) { ctx.LEAQ(m, r) } 6631 6632// LEAW: Load Effective Address. 6633// 6634// Forms: 6635// 6636// LEAW m r16 6637// Construct and append a LEAW instruction to the active function. 6638func (c *Context) LEAW(m, r operand.Op) { 6639 if inst, err := x86.LEAW(m, r); err == nil { 6640 c.Instruction(inst) 6641 } else { 6642 c.adderror(err) 6643 } 6644} 6645 6646// LEAW: Load Effective Address. 6647// 6648// Forms: 6649// 6650// LEAW m r16 6651// Construct and append a LEAW instruction to the active function. 6652// Operates on the global context. 6653func LEAW(m, r operand.Op) { ctx.LEAW(m, r) } 6654 6655// LFENCE: Load Fence. 6656// 6657// Forms: 6658// 6659// LFENCE 6660// Construct and append a LFENCE instruction to the active function. 6661func (c *Context) LFENCE() { 6662 if inst, err := x86.LFENCE(); err == nil { 6663 c.Instruction(inst) 6664 } else { 6665 c.adderror(err) 6666 } 6667} 6668 6669// LFENCE: Load Fence. 6670// 6671// Forms: 6672// 6673// LFENCE 6674// Construct and append a LFENCE instruction to the active function. 6675// Operates on the global context. 6676func LFENCE() { ctx.LFENCE() } 6677 6678// LZCNTL: Count the Number of Leading Zero Bits. 6679// 6680// Forms: 6681// 6682// LZCNTL r32 r32 6683// LZCNTL m32 r32 6684// Construct and append a LZCNTL instruction to the active function. 6685func (c *Context) LZCNTL(mr, r operand.Op) { 6686 if inst, err := x86.LZCNTL(mr, r); err == nil { 6687 c.Instruction(inst) 6688 } else { 6689 c.adderror(err) 6690 } 6691} 6692 6693// LZCNTL: Count the Number of Leading Zero Bits. 6694// 6695// Forms: 6696// 6697// LZCNTL r32 r32 6698// LZCNTL m32 r32 6699// Construct and append a LZCNTL instruction to the active function. 6700// Operates on the global context. 6701func LZCNTL(mr, r operand.Op) { ctx.LZCNTL(mr, r) } 6702 6703// LZCNTQ: Count the Number of Leading Zero Bits. 6704// 6705// Forms: 6706// 6707// LZCNTQ r64 r64 6708// LZCNTQ m64 r64 6709// Construct and append a LZCNTQ instruction to the active function. 6710func (c *Context) LZCNTQ(mr, r operand.Op) { 6711 if inst, err := x86.LZCNTQ(mr, r); err == nil { 6712 c.Instruction(inst) 6713 } else { 6714 c.adderror(err) 6715 } 6716} 6717 6718// LZCNTQ: Count the Number of Leading Zero Bits. 6719// 6720// Forms: 6721// 6722// LZCNTQ r64 r64 6723// LZCNTQ m64 r64 6724// Construct and append a LZCNTQ instruction to the active function. 6725// Operates on the global context. 6726func LZCNTQ(mr, r operand.Op) { ctx.LZCNTQ(mr, r) } 6727 6728// LZCNTW: Count the Number of Leading Zero Bits. 6729// 6730// Forms: 6731// 6732// LZCNTW r16 r16 6733// LZCNTW m16 r16 6734// Construct and append a LZCNTW instruction to the active function. 6735func (c *Context) LZCNTW(mr, r operand.Op) { 6736 if inst, err := x86.LZCNTW(mr, r); err == nil { 6737 c.Instruction(inst) 6738 } else { 6739 c.adderror(err) 6740 } 6741} 6742 6743// LZCNTW: Count the Number of Leading Zero Bits. 6744// 6745// Forms: 6746// 6747// LZCNTW r16 r16 6748// LZCNTW m16 r16 6749// Construct and append a LZCNTW instruction to the active function. 6750// Operates on the global context. 6751func LZCNTW(mr, r operand.Op) { ctx.LZCNTW(mr, r) } 6752 6753// MASKMOVDQU: Store Selected Bytes of Double Quadword. 6754// 6755// Forms: 6756// 6757// MASKMOVDQU xmm xmm 6758// Construct and append a MASKMOVDQU instruction to the active function. 6759func (c *Context) MASKMOVDQU(x, x1 operand.Op) { 6760 if inst, err := x86.MASKMOVDQU(x, x1); err == nil { 6761 c.Instruction(inst) 6762 } else { 6763 c.adderror(err) 6764 } 6765} 6766 6767// MASKMOVDQU: Store Selected Bytes of Double Quadword. 6768// 6769// Forms: 6770// 6771// MASKMOVDQU xmm xmm 6772// Construct and append a MASKMOVDQU instruction to the active function. 6773// Operates on the global context. 6774func MASKMOVDQU(x, x1 operand.Op) { ctx.MASKMOVDQU(x, x1) } 6775 6776// MASKMOVOU: Store Selected Bytes of Double Quadword. 6777// 6778// Forms: 6779// 6780// MASKMOVOU xmm xmm 6781// Construct and append a MASKMOVOU instruction to the active function. 6782func (c *Context) MASKMOVOU(x, x1 operand.Op) { 6783 if inst, err := x86.MASKMOVOU(x, x1); err == nil { 6784 c.Instruction(inst) 6785 } else { 6786 c.adderror(err) 6787 } 6788} 6789 6790// MASKMOVOU: Store Selected Bytes of Double Quadword. 6791// 6792// Forms: 6793// 6794// MASKMOVOU xmm xmm 6795// Construct and append a MASKMOVOU instruction to the active function. 6796// Operates on the global context. 6797func MASKMOVOU(x, x1 operand.Op) { ctx.MASKMOVOU(x, x1) } 6798 6799// MAXPD: Return Maximum Packed Double-Precision Floating-Point Values. 6800// 6801// Forms: 6802// 6803// MAXPD xmm xmm 6804// MAXPD m128 xmm 6805// Construct and append a MAXPD instruction to the active function. 6806func (c *Context) MAXPD(mx, x operand.Op) { 6807 if inst, err := x86.MAXPD(mx, x); err == nil { 6808 c.Instruction(inst) 6809 } else { 6810 c.adderror(err) 6811 } 6812} 6813 6814// MAXPD: Return Maximum Packed Double-Precision Floating-Point Values. 6815// 6816// Forms: 6817// 6818// MAXPD xmm xmm 6819// MAXPD m128 xmm 6820// Construct and append a MAXPD instruction to the active function. 6821// Operates on the global context. 6822func MAXPD(mx, x operand.Op) { ctx.MAXPD(mx, x) } 6823 6824// MAXPS: Return Maximum Packed Single-Precision Floating-Point Values. 6825// 6826// Forms: 6827// 6828// MAXPS xmm xmm 6829// MAXPS m128 xmm 6830// Construct and append a MAXPS instruction to the active function. 6831func (c *Context) MAXPS(mx, x operand.Op) { 6832 if inst, err := x86.MAXPS(mx, x); err == nil { 6833 c.Instruction(inst) 6834 } else { 6835 c.adderror(err) 6836 } 6837} 6838 6839// MAXPS: Return Maximum Packed Single-Precision Floating-Point Values. 6840// 6841// Forms: 6842// 6843// MAXPS xmm xmm 6844// MAXPS m128 xmm 6845// Construct and append a MAXPS instruction to the active function. 6846// Operates on the global context. 6847func MAXPS(mx, x operand.Op) { ctx.MAXPS(mx, x) } 6848 6849// MAXSD: Return Maximum Scalar Double-Precision Floating-Point Value. 6850// 6851// Forms: 6852// 6853// MAXSD xmm xmm 6854// MAXSD m64 xmm 6855// Construct and append a MAXSD instruction to the active function. 6856func (c *Context) MAXSD(mx, x operand.Op) { 6857 if inst, err := x86.MAXSD(mx, x); err == nil { 6858 c.Instruction(inst) 6859 } else { 6860 c.adderror(err) 6861 } 6862} 6863 6864// MAXSD: Return Maximum Scalar Double-Precision Floating-Point Value. 6865// 6866// Forms: 6867// 6868// MAXSD xmm xmm 6869// MAXSD m64 xmm 6870// Construct and append a MAXSD instruction to the active function. 6871// Operates on the global context. 6872func MAXSD(mx, x operand.Op) { ctx.MAXSD(mx, x) } 6873 6874// MAXSS: Return Maximum Scalar Single-Precision Floating-Point Value. 6875// 6876// Forms: 6877// 6878// MAXSS xmm xmm 6879// MAXSS m32 xmm 6880// Construct and append a MAXSS instruction to the active function. 6881func (c *Context) MAXSS(mx, x operand.Op) { 6882 if inst, err := x86.MAXSS(mx, x); err == nil { 6883 c.Instruction(inst) 6884 } else { 6885 c.adderror(err) 6886 } 6887} 6888 6889// MAXSS: Return Maximum Scalar Single-Precision Floating-Point Value. 6890// 6891// Forms: 6892// 6893// MAXSS xmm xmm 6894// MAXSS m32 xmm 6895// Construct and append a MAXSS instruction to the active function. 6896// Operates on the global context. 6897func MAXSS(mx, x operand.Op) { ctx.MAXSS(mx, x) } 6898 6899// MFENCE: Memory Fence. 6900// 6901// Forms: 6902// 6903// MFENCE 6904// Construct and append a MFENCE instruction to the active function. 6905func (c *Context) MFENCE() { 6906 if inst, err := x86.MFENCE(); err == nil { 6907 c.Instruction(inst) 6908 } else { 6909 c.adderror(err) 6910 } 6911} 6912 6913// MFENCE: Memory Fence. 6914// 6915// Forms: 6916// 6917// MFENCE 6918// Construct and append a MFENCE instruction to the active function. 6919// Operates on the global context. 6920func MFENCE() { ctx.MFENCE() } 6921 6922// MINPD: Return Minimum Packed Double-Precision Floating-Point Values. 6923// 6924// Forms: 6925// 6926// MINPD xmm xmm 6927// MINPD m128 xmm 6928// Construct and append a MINPD instruction to the active function. 6929func (c *Context) MINPD(mx, x operand.Op) { 6930 if inst, err := x86.MINPD(mx, x); err == nil { 6931 c.Instruction(inst) 6932 } else { 6933 c.adderror(err) 6934 } 6935} 6936 6937// MINPD: Return Minimum Packed Double-Precision Floating-Point Values. 6938// 6939// Forms: 6940// 6941// MINPD xmm xmm 6942// MINPD m128 xmm 6943// Construct and append a MINPD instruction to the active function. 6944// Operates on the global context. 6945func MINPD(mx, x operand.Op) { ctx.MINPD(mx, x) } 6946 6947// MINPS: Return Minimum Packed Single-Precision Floating-Point Values. 6948// 6949// Forms: 6950// 6951// MINPS xmm xmm 6952// MINPS m128 xmm 6953// Construct and append a MINPS instruction to the active function. 6954func (c *Context) MINPS(mx, x operand.Op) { 6955 if inst, err := x86.MINPS(mx, x); err == nil { 6956 c.Instruction(inst) 6957 } else { 6958 c.adderror(err) 6959 } 6960} 6961 6962// MINPS: Return Minimum Packed Single-Precision Floating-Point Values. 6963// 6964// Forms: 6965// 6966// MINPS xmm xmm 6967// MINPS m128 xmm 6968// Construct and append a MINPS instruction to the active function. 6969// Operates on the global context. 6970func MINPS(mx, x operand.Op) { ctx.MINPS(mx, x) } 6971 6972// MINSD: Return Minimum Scalar Double-Precision Floating-Point Value. 6973// 6974// Forms: 6975// 6976// MINSD xmm xmm 6977// MINSD m64 xmm 6978// Construct and append a MINSD instruction to the active function. 6979func (c *Context) MINSD(mx, x operand.Op) { 6980 if inst, err := x86.MINSD(mx, x); err == nil { 6981 c.Instruction(inst) 6982 } else { 6983 c.adderror(err) 6984 } 6985} 6986 6987// MINSD: Return Minimum Scalar Double-Precision Floating-Point Value. 6988// 6989// Forms: 6990// 6991// MINSD xmm xmm 6992// MINSD m64 xmm 6993// Construct and append a MINSD instruction to the active function. 6994// Operates on the global context. 6995func MINSD(mx, x operand.Op) { ctx.MINSD(mx, x) } 6996 6997// MINSS: Return Minimum Scalar Single-Precision Floating-Point Value. 6998// 6999// Forms: 7000// 7001// MINSS xmm xmm 7002// MINSS m32 xmm 7003// Construct and append a MINSS instruction to the active function. 7004func (c *Context) MINSS(mx, x operand.Op) { 7005 if inst, err := x86.MINSS(mx, x); err == nil { 7006 c.Instruction(inst) 7007 } else { 7008 c.adderror(err) 7009 } 7010} 7011 7012// MINSS: Return Minimum Scalar Single-Precision Floating-Point Value. 7013// 7014// Forms: 7015// 7016// MINSS xmm xmm 7017// MINSS m32 xmm 7018// Construct and append a MINSS instruction to the active function. 7019// Operates on the global context. 7020func MINSS(mx, x operand.Op) { ctx.MINSS(mx, x) } 7021 7022// MONITOR: Monitor a Linear Address Range. 7023// 7024// Forms: 7025// 7026// MONITOR 7027// Construct and append a MONITOR instruction to the active function. 7028func (c *Context) MONITOR() { 7029 if inst, err := x86.MONITOR(); err == nil { 7030 c.Instruction(inst) 7031 } else { 7032 c.adderror(err) 7033 } 7034} 7035 7036// MONITOR: Monitor a Linear Address Range. 7037// 7038// Forms: 7039// 7040// MONITOR 7041// Construct and append a MONITOR instruction to the active function. 7042// Operates on the global context. 7043func MONITOR() { ctx.MONITOR() } 7044 7045// MOVAPD: Move Aligned Packed Double-Precision Floating-Point Values. 7046// 7047// Forms: 7048// 7049// MOVAPD xmm xmm 7050// MOVAPD m128 xmm 7051// MOVAPD xmm m128 7052// Construct and append a MOVAPD instruction to the active function. 7053func (c *Context) MOVAPD(mx, mx1 operand.Op) { 7054 if inst, err := x86.MOVAPD(mx, mx1); err == nil { 7055 c.Instruction(inst) 7056 } else { 7057 c.adderror(err) 7058 } 7059} 7060 7061// MOVAPD: Move Aligned Packed Double-Precision Floating-Point Values. 7062// 7063// Forms: 7064// 7065// MOVAPD xmm xmm 7066// MOVAPD m128 xmm 7067// MOVAPD xmm m128 7068// Construct and append a MOVAPD instruction to the active function. 7069// Operates on the global context. 7070func MOVAPD(mx, mx1 operand.Op) { ctx.MOVAPD(mx, mx1) } 7071 7072// MOVAPS: Move Aligned Packed Single-Precision Floating-Point Values. 7073// 7074// Forms: 7075// 7076// MOVAPS xmm xmm 7077// MOVAPS m128 xmm 7078// MOVAPS xmm m128 7079// Construct and append a MOVAPS instruction to the active function. 7080func (c *Context) MOVAPS(mx, mx1 operand.Op) { 7081 if inst, err := x86.MOVAPS(mx, mx1); err == nil { 7082 c.Instruction(inst) 7083 } else { 7084 c.adderror(err) 7085 } 7086} 7087 7088// MOVAPS: Move Aligned Packed Single-Precision Floating-Point Values. 7089// 7090// Forms: 7091// 7092// MOVAPS xmm xmm 7093// MOVAPS m128 xmm 7094// MOVAPS xmm m128 7095// Construct and append a MOVAPS instruction to the active function. 7096// Operates on the global context. 7097func MOVAPS(mx, mx1 operand.Op) { ctx.MOVAPS(mx, mx1) } 7098 7099// MOVB: Move. 7100// 7101// Forms: 7102// 7103// MOVB imm8 r8 7104// MOVB r8 r8 7105// MOVB m8 r8 7106// MOVB imm8 m8 7107// MOVB r8 m8 7108// Construct and append a MOVB instruction to the active function. 7109func (c *Context) MOVB(imr, mr operand.Op) { 7110 if inst, err := x86.MOVB(imr, mr); err == nil { 7111 c.Instruction(inst) 7112 } else { 7113 c.adderror(err) 7114 } 7115} 7116 7117// MOVB: Move. 7118// 7119// Forms: 7120// 7121// MOVB imm8 r8 7122// MOVB r8 r8 7123// MOVB m8 r8 7124// MOVB imm8 m8 7125// MOVB r8 m8 7126// Construct and append a MOVB instruction to the active function. 7127// Operates on the global context. 7128func MOVB(imr, mr operand.Op) { ctx.MOVB(imr, mr) } 7129 7130// MOVBELL: Move Data After Swapping Bytes. 7131// 7132// Forms: 7133// 7134// MOVBELL m32 r32 7135// MOVBELL r32 m32 7136// Construct and append a MOVBELL instruction to the active function. 7137func (c *Context) MOVBELL(mr, mr1 operand.Op) { 7138 if inst, err := x86.MOVBELL(mr, mr1); err == nil { 7139 c.Instruction(inst) 7140 } else { 7141 c.adderror(err) 7142 } 7143} 7144 7145// MOVBELL: Move Data After Swapping Bytes. 7146// 7147// Forms: 7148// 7149// MOVBELL m32 r32 7150// MOVBELL r32 m32 7151// Construct and append a MOVBELL instruction to the active function. 7152// Operates on the global context. 7153func MOVBELL(mr, mr1 operand.Op) { ctx.MOVBELL(mr, mr1) } 7154 7155// MOVBEQQ: Move Data After Swapping Bytes. 7156// 7157// Forms: 7158// 7159// MOVBEQQ m64 r64 7160// MOVBEQQ r64 m64 7161// Construct and append a MOVBEQQ instruction to the active function. 7162func (c *Context) MOVBEQQ(mr, mr1 operand.Op) { 7163 if inst, err := x86.MOVBEQQ(mr, mr1); err == nil { 7164 c.Instruction(inst) 7165 } else { 7166 c.adderror(err) 7167 } 7168} 7169 7170// MOVBEQQ: Move Data After Swapping Bytes. 7171// 7172// Forms: 7173// 7174// MOVBEQQ m64 r64 7175// MOVBEQQ r64 m64 7176// Construct and append a MOVBEQQ instruction to the active function. 7177// Operates on the global context. 7178func MOVBEQQ(mr, mr1 operand.Op) { ctx.MOVBEQQ(mr, mr1) } 7179 7180// MOVBEWW: Move Data After Swapping Bytes. 7181// 7182// Forms: 7183// 7184// MOVBEWW m16 r16 7185// MOVBEWW r16 m16 7186// Construct and append a MOVBEWW instruction to the active function. 7187func (c *Context) MOVBEWW(mr, mr1 operand.Op) { 7188 if inst, err := x86.MOVBEWW(mr, mr1); err == nil { 7189 c.Instruction(inst) 7190 } else { 7191 c.adderror(err) 7192 } 7193} 7194 7195// MOVBEWW: Move Data After Swapping Bytes. 7196// 7197// Forms: 7198// 7199// MOVBEWW m16 r16 7200// MOVBEWW r16 m16 7201// Construct and append a MOVBEWW instruction to the active function. 7202// Operates on the global context. 7203func MOVBEWW(mr, mr1 operand.Op) { ctx.MOVBEWW(mr, mr1) } 7204 7205// MOVBLSX: Move with Sign-Extension. 7206// 7207// Forms: 7208// 7209// MOVBLSX r8 r32 7210// MOVBLSX m8 r32 7211// Construct and append a MOVBLSX instruction to the active function. 7212func (c *Context) MOVBLSX(mr, r operand.Op) { 7213 if inst, err := x86.MOVBLSX(mr, r); err == nil { 7214 c.Instruction(inst) 7215 } else { 7216 c.adderror(err) 7217 } 7218} 7219 7220// MOVBLSX: Move with Sign-Extension. 7221// 7222// Forms: 7223// 7224// MOVBLSX r8 r32 7225// MOVBLSX m8 r32 7226// Construct and append a MOVBLSX instruction to the active function. 7227// Operates on the global context. 7228func MOVBLSX(mr, r operand.Op) { ctx.MOVBLSX(mr, r) } 7229 7230// MOVBLZX: Move with Zero-Extend. 7231// 7232// Forms: 7233// 7234// MOVBLZX r8 r32 7235// MOVBLZX m8 r32 7236// Construct and append a MOVBLZX instruction to the active function. 7237func (c *Context) MOVBLZX(mr, r operand.Op) { 7238 if inst, err := x86.MOVBLZX(mr, r); err == nil { 7239 c.Instruction(inst) 7240 } else { 7241 c.adderror(err) 7242 } 7243} 7244 7245// MOVBLZX: Move with Zero-Extend. 7246// 7247// Forms: 7248// 7249// MOVBLZX r8 r32 7250// MOVBLZX m8 r32 7251// Construct and append a MOVBLZX instruction to the active function. 7252// Operates on the global context. 7253func MOVBLZX(mr, r operand.Op) { ctx.MOVBLZX(mr, r) } 7254 7255// MOVBQSX: Move with Sign-Extension. 7256// 7257// Forms: 7258// 7259// MOVBQSX r8 r64 7260// MOVBQSX m8 r64 7261// Construct and append a MOVBQSX instruction to the active function. 7262func (c *Context) MOVBQSX(mr, r operand.Op) { 7263 if inst, err := x86.MOVBQSX(mr, r); err == nil { 7264 c.Instruction(inst) 7265 } else { 7266 c.adderror(err) 7267 } 7268} 7269 7270// MOVBQSX: Move with Sign-Extension. 7271// 7272// Forms: 7273// 7274// MOVBQSX r8 r64 7275// MOVBQSX m8 r64 7276// Construct and append a MOVBQSX instruction to the active function. 7277// Operates on the global context. 7278func MOVBQSX(mr, r operand.Op) { ctx.MOVBQSX(mr, r) } 7279 7280// MOVBQZX: Move with Zero-Extend. 7281// 7282// Forms: 7283// 7284// MOVBQZX r8 r64 7285// MOVBQZX m8 r64 7286// Construct and append a MOVBQZX instruction to the active function. 7287func (c *Context) MOVBQZX(mr, r operand.Op) { 7288 if inst, err := x86.MOVBQZX(mr, r); err == nil { 7289 c.Instruction(inst) 7290 } else { 7291 c.adderror(err) 7292 } 7293} 7294 7295// MOVBQZX: Move with Zero-Extend. 7296// 7297// Forms: 7298// 7299// MOVBQZX r8 r64 7300// MOVBQZX m8 r64 7301// Construct and append a MOVBQZX instruction to the active function. 7302// Operates on the global context. 7303func MOVBQZX(mr, r operand.Op) { ctx.MOVBQZX(mr, r) } 7304 7305// MOVBWSX: Move with Sign-Extension. 7306// 7307// Forms: 7308// 7309// MOVBWSX r8 r16 7310// MOVBWSX m8 r16 7311// Construct and append a MOVBWSX instruction to the active function. 7312func (c *Context) MOVBWSX(mr, r operand.Op) { 7313 if inst, err := x86.MOVBWSX(mr, r); err == nil { 7314 c.Instruction(inst) 7315 } else { 7316 c.adderror(err) 7317 } 7318} 7319 7320// MOVBWSX: Move with Sign-Extension. 7321// 7322// Forms: 7323// 7324// MOVBWSX r8 r16 7325// MOVBWSX m8 r16 7326// Construct and append a MOVBWSX instruction to the active function. 7327// Operates on the global context. 7328func MOVBWSX(mr, r operand.Op) { ctx.MOVBWSX(mr, r) } 7329 7330// MOVBWZX: Move with Zero-Extend. 7331// 7332// Forms: 7333// 7334// MOVBWZX r8 r16 7335// MOVBWZX m8 r16 7336// Construct and append a MOVBWZX instruction to the active function. 7337func (c *Context) MOVBWZX(mr, r operand.Op) { 7338 if inst, err := x86.MOVBWZX(mr, r); err == nil { 7339 c.Instruction(inst) 7340 } else { 7341 c.adderror(err) 7342 } 7343} 7344 7345// MOVBWZX: Move with Zero-Extend. 7346// 7347// Forms: 7348// 7349// MOVBWZX r8 r16 7350// MOVBWZX m8 r16 7351// Construct and append a MOVBWZX instruction to the active function. 7352// Operates on the global context. 7353func MOVBWZX(mr, r operand.Op) { ctx.MOVBWZX(mr, r) } 7354 7355// MOVD: Move. 7356// 7357// Forms: 7358// 7359// MOVD imm32 r64 7360// MOVD imm64 r64 7361// MOVD r64 r64 7362// MOVD m64 r64 7363// MOVD imm32 m64 7364// MOVD r64 m64 7365// MOVD xmm r64 7366// MOVD r64 xmm 7367// MOVD xmm xmm 7368// MOVD m64 xmm 7369// MOVD xmm m64 7370// MOVD xmm r32 7371// MOVD r32 xmm 7372// MOVD m32 xmm 7373// MOVD xmm m32 7374// Construct and append a MOVD instruction to the active function. 7375func (c *Context) MOVD(imrx, mrx operand.Op) { 7376 if inst, err := x86.MOVD(imrx, mrx); err == nil { 7377 c.Instruction(inst) 7378 } else { 7379 c.adderror(err) 7380 } 7381} 7382 7383// MOVD: Move. 7384// 7385// Forms: 7386// 7387// MOVD imm32 r64 7388// MOVD imm64 r64 7389// MOVD r64 r64 7390// MOVD m64 r64 7391// MOVD imm32 m64 7392// MOVD r64 m64 7393// MOVD xmm r64 7394// MOVD r64 xmm 7395// MOVD xmm xmm 7396// MOVD m64 xmm 7397// MOVD xmm m64 7398// MOVD xmm r32 7399// MOVD r32 xmm 7400// MOVD m32 xmm 7401// MOVD xmm m32 7402// Construct and append a MOVD instruction to the active function. 7403// Operates on the global context. 7404func MOVD(imrx, mrx operand.Op) { ctx.MOVD(imrx, mrx) } 7405 7406// MOVDDUP: Move One Double-FP and Duplicate. 7407// 7408// Forms: 7409// 7410// MOVDDUP xmm xmm 7411// MOVDDUP m64 xmm 7412// Construct and append a MOVDDUP instruction to the active function. 7413func (c *Context) MOVDDUP(mx, x operand.Op) { 7414 if inst, err := x86.MOVDDUP(mx, x); err == nil { 7415 c.Instruction(inst) 7416 } else { 7417 c.adderror(err) 7418 } 7419} 7420 7421// MOVDDUP: Move One Double-FP and Duplicate. 7422// 7423// Forms: 7424// 7425// MOVDDUP xmm xmm 7426// MOVDDUP m64 xmm 7427// Construct and append a MOVDDUP instruction to the active function. 7428// Operates on the global context. 7429func MOVDDUP(mx, x operand.Op) { ctx.MOVDDUP(mx, x) } 7430 7431// MOVDQ2Q: Move. 7432// 7433// Forms: 7434// 7435// MOVDQ2Q imm32 r64 7436// MOVDQ2Q imm64 r64 7437// MOVDQ2Q r64 r64 7438// MOVDQ2Q m64 r64 7439// MOVDQ2Q imm32 m64 7440// MOVDQ2Q r64 m64 7441// MOVDQ2Q xmm r64 7442// MOVDQ2Q r64 xmm 7443// MOVDQ2Q xmm xmm 7444// MOVDQ2Q m64 xmm 7445// MOVDQ2Q xmm m64 7446// MOVDQ2Q xmm r32 7447// MOVDQ2Q r32 xmm 7448// MOVDQ2Q m32 xmm 7449// MOVDQ2Q xmm m32 7450// Construct and append a MOVDQ2Q instruction to the active function. 7451func (c *Context) MOVDQ2Q(imrx, mrx operand.Op) { 7452 if inst, err := x86.MOVDQ2Q(imrx, mrx); err == nil { 7453 c.Instruction(inst) 7454 } else { 7455 c.adderror(err) 7456 } 7457} 7458 7459// MOVDQ2Q: Move. 7460// 7461// Forms: 7462// 7463// MOVDQ2Q imm32 r64 7464// MOVDQ2Q imm64 r64 7465// MOVDQ2Q r64 r64 7466// MOVDQ2Q m64 r64 7467// MOVDQ2Q imm32 m64 7468// MOVDQ2Q r64 m64 7469// MOVDQ2Q xmm r64 7470// MOVDQ2Q r64 xmm 7471// MOVDQ2Q xmm xmm 7472// MOVDQ2Q m64 xmm 7473// MOVDQ2Q xmm m64 7474// MOVDQ2Q xmm r32 7475// MOVDQ2Q r32 xmm 7476// MOVDQ2Q m32 xmm 7477// MOVDQ2Q xmm m32 7478// Construct and append a MOVDQ2Q instruction to the active function. 7479// Operates on the global context. 7480func MOVDQ2Q(imrx, mrx operand.Op) { ctx.MOVDQ2Q(imrx, mrx) } 7481 7482// MOVHLPS: Move Packed Single-Precision Floating-Point Values High to Low. 7483// 7484// Forms: 7485// 7486// MOVHLPS xmm xmm 7487// Construct and append a MOVHLPS instruction to the active function. 7488func (c *Context) MOVHLPS(x, x1 operand.Op) { 7489 if inst, err := x86.MOVHLPS(x, x1); err == nil { 7490 c.Instruction(inst) 7491 } else { 7492 c.adderror(err) 7493 } 7494} 7495 7496// MOVHLPS: Move Packed Single-Precision Floating-Point Values High to Low. 7497// 7498// Forms: 7499// 7500// MOVHLPS xmm xmm 7501// Construct and append a MOVHLPS instruction to the active function. 7502// Operates on the global context. 7503func MOVHLPS(x, x1 operand.Op) { ctx.MOVHLPS(x, x1) } 7504 7505// MOVHPD: Move High Packed Double-Precision Floating-Point Value. 7506// 7507// Forms: 7508// 7509// MOVHPD m64 xmm 7510// MOVHPD xmm m64 7511// Construct and append a MOVHPD instruction to the active function. 7512func (c *Context) MOVHPD(mx, mx1 operand.Op) { 7513 if inst, err := x86.MOVHPD(mx, mx1); err == nil { 7514 c.Instruction(inst) 7515 } else { 7516 c.adderror(err) 7517 } 7518} 7519 7520// MOVHPD: Move High Packed Double-Precision Floating-Point Value. 7521// 7522// Forms: 7523// 7524// MOVHPD m64 xmm 7525// MOVHPD xmm m64 7526// Construct and append a MOVHPD instruction to the active function. 7527// Operates on the global context. 7528func MOVHPD(mx, mx1 operand.Op) { ctx.MOVHPD(mx, mx1) } 7529 7530// MOVHPS: Move High Packed Single-Precision Floating-Point Values. 7531// 7532// Forms: 7533// 7534// MOVHPS m64 xmm 7535// MOVHPS xmm m64 7536// Construct and append a MOVHPS instruction to the active function. 7537func (c *Context) MOVHPS(mx, mx1 operand.Op) { 7538 if inst, err := x86.MOVHPS(mx, mx1); err == nil { 7539 c.Instruction(inst) 7540 } else { 7541 c.adderror(err) 7542 } 7543} 7544 7545// MOVHPS: Move High Packed Single-Precision Floating-Point Values. 7546// 7547// Forms: 7548// 7549// MOVHPS m64 xmm 7550// MOVHPS xmm m64 7551// Construct and append a MOVHPS instruction to the active function. 7552// Operates on the global context. 7553func MOVHPS(mx, mx1 operand.Op) { ctx.MOVHPS(mx, mx1) } 7554 7555// MOVL: Move. 7556// 7557// Forms: 7558// 7559// MOVL imm32 r32 7560// MOVL r32 r32 7561// MOVL m32 r32 7562// MOVL imm32 m32 7563// MOVL r32 m32 7564// Construct and append a MOVL instruction to the active function. 7565func (c *Context) MOVL(imr, mr operand.Op) { 7566 if inst, err := x86.MOVL(imr, mr); err == nil { 7567 c.Instruction(inst) 7568 } else { 7569 c.adderror(err) 7570 } 7571} 7572 7573// MOVL: Move. 7574// 7575// Forms: 7576// 7577// MOVL imm32 r32 7578// MOVL r32 r32 7579// MOVL m32 r32 7580// MOVL imm32 m32 7581// MOVL r32 m32 7582// Construct and append a MOVL instruction to the active function. 7583// Operates on the global context. 7584func MOVL(imr, mr operand.Op) { ctx.MOVL(imr, mr) } 7585 7586// MOVLHPS: Move Packed Single-Precision Floating-Point Values Low to High. 7587// 7588// Forms: 7589// 7590// MOVLHPS xmm xmm 7591// Construct and append a MOVLHPS instruction to the active function. 7592func (c *Context) MOVLHPS(x, x1 operand.Op) { 7593 if inst, err := x86.MOVLHPS(x, x1); err == nil { 7594 c.Instruction(inst) 7595 } else { 7596 c.adderror(err) 7597 } 7598} 7599 7600// MOVLHPS: Move Packed Single-Precision Floating-Point Values Low to High. 7601// 7602// Forms: 7603// 7604// MOVLHPS xmm xmm 7605// Construct and append a MOVLHPS instruction to the active function. 7606// Operates on the global context. 7607func MOVLHPS(x, x1 operand.Op) { ctx.MOVLHPS(x, x1) } 7608 7609// MOVLPD: Move Low Packed Double-Precision Floating-Point Value. 7610// 7611// Forms: 7612// 7613// MOVLPD m64 xmm 7614// MOVLPD xmm m64 7615// Construct and append a MOVLPD instruction to the active function. 7616func (c *Context) MOVLPD(mx, mx1 operand.Op) { 7617 if inst, err := x86.MOVLPD(mx, mx1); err == nil { 7618 c.Instruction(inst) 7619 } else { 7620 c.adderror(err) 7621 } 7622} 7623 7624// MOVLPD: Move Low Packed Double-Precision Floating-Point Value. 7625// 7626// Forms: 7627// 7628// MOVLPD m64 xmm 7629// MOVLPD xmm m64 7630// Construct and append a MOVLPD instruction to the active function. 7631// Operates on the global context. 7632func MOVLPD(mx, mx1 operand.Op) { ctx.MOVLPD(mx, mx1) } 7633 7634// MOVLPS: Move Low Packed Single-Precision Floating-Point Values. 7635// 7636// Forms: 7637// 7638// MOVLPS m64 xmm 7639// MOVLPS xmm m64 7640// Construct and append a MOVLPS instruction to the active function. 7641func (c *Context) MOVLPS(mx, mx1 operand.Op) { 7642 if inst, err := x86.MOVLPS(mx, mx1); err == nil { 7643 c.Instruction(inst) 7644 } else { 7645 c.adderror(err) 7646 } 7647} 7648 7649// MOVLPS: Move Low Packed Single-Precision Floating-Point Values. 7650// 7651// Forms: 7652// 7653// MOVLPS m64 xmm 7654// MOVLPS xmm m64 7655// Construct and append a MOVLPS instruction to the active function. 7656// Operates on the global context. 7657func MOVLPS(mx, mx1 operand.Op) { ctx.MOVLPS(mx, mx1) } 7658 7659// MOVLQSX: Move Doubleword to Quadword with Sign-Extension. 7660// 7661// Forms: 7662// 7663// MOVLQSX r32 r64 7664// MOVLQSX m32 r64 7665// Construct and append a MOVLQSX instruction to the active function. 7666func (c *Context) MOVLQSX(mr, r operand.Op) { 7667 if inst, err := x86.MOVLQSX(mr, r); err == nil { 7668 c.Instruction(inst) 7669 } else { 7670 c.adderror(err) 7671 } 7672} 7673 7674// MOVLQSX: Move Doubleword to Quadword with Sign-Extension. 7675// 7676// Forms: 7677// 7678// MOVLQSX r32 r64 7679// MOVLQSX m32 r64 7680// Construct and append a MOVLQSX instruction to the active function. 7681// Operates on the global context. 7682func MOVLQSX(mr, r operand.Op) { ctx.MOVLQSX(mr, r) } 7683 7684// MOVLQZX: Move with Zero-Extend. 7685// 7686// Forms: 7687// 7688// MOVLQZX m32 r64 7689// Construct and append a MOVLQZX instruction to the active function. 7690func (c *Context) MOVLQZX(m, r operand.Op) { 7691 if inst, err := x86.MOVLQZX(m, r); err == nil { 7692 c.Instruction(inst) 7693 } else { 7694 c.adderror(err) 7695 } 7696} 7697 7698// MOVLQZX: Move with Zero-Extend. 7699// 7700// Forms: 7701// 7702// MOVLQZX m32 r64 7703// Construct and append a MOVLQZX instruction to the active function. 7704// Operates on the global context. 7705func MOVLQZX(m, r operand.Op) { ctx.MOVLQZX(m, r) } 7706 7707// MOVMSKPD: Extract Packed Double-Precision Floating-Point Sign Mask. 7708// 7709// Forms: 7710// 7711// MOVMSKPD xmm r32 7712// Construct and append a MOVMSKPD instruction to the active function. 7713func (c *Context) MOVMSKPD(x, r operand.Op) { 7714 if inst, err := x86.MOVMSKPD(x, r); err == nil { 7715 c.Instruction(inst) 7716 } else { 7717 c.adderror(err) 7718 } 7719} 7720 7721// MOVMSKPD: Extract Packed Double-Precision Floating-Point Sign Mask. 7722// 7723// Forms: 7724// 7725// MOVMSKPD xmm r32 7726// Construct and append a MOVMSKPD instruction to the active function. 7727// Operates on the global context. 7728func MOVMSKPD(x, r operand.Op) { ctx.MOVMSKPD(x, r) } 7729 7730// MOVMSKPS: Extract Packed Single-Precision Floating-Point Sign Mask. 7731// 7732// Forms: 7733// 7734// MOVMSKPS xmm r32 7735// Construct and append a MOVMSKPS instruction to the active function. 7736func (c *Context) MOVMSKPS(x, r operand.Op) { 7737 if inst, err := x86.MOVMSKPS(x, r); err == nil { 7738 c.Instruction(inst) 7739 } else { 7740 c.adderror(err) 7741 } 7742} 7743 7744// MOVMSKPS: Extract Packed Single-Precision Floating-Point Sign Mask. 7745// 7746// Forms: 7747// 7748// MOVMSKPS xmm r32 7749// Construct and append a MOVMSKPS instruction to the active function. 7750// Operates on the global context. 7751func MOVMSKPS(x, r operand.Op) { ctx.MOVMSKPS(x, r) } 7752 7753// MOVNTDQ: Store Double Quadword Using Non-Temporal Hint. 7754// 7755// Forms: 7756// 7757// MOVNTDQ xmm m128 7758// Construct and append a MOVNTDQ instruction to the active function. 7759func (c *Context) MOVNTDQ(x, m operand.Op) { 7760 if inst, err := x86.MOVNTDQ(x, m); err == nil { 7761 c.Instruction(inst) 7762 } else { 7763 c.adderror(err) 7764 } 7765} 7766 7767// MOVNTDQ: Store Double Quadword Using Non-Temporal Hint. 7768// 7769// Forms: 7770// 7771// MOVNTDQ xmm m128 7772// Construct and append a MOVNTDQ instruction to the active function. 7773// Operates on the global context. 7774func MOVNTDQ(x, m operand.Op) { ctx.MOVNTDQ(x, m) } 7775 7776// MOVNTDQA: Load Double Quadword Non-Temporal Aligned Hint. 7777// 7778// Forms: 7779// 7780// MOVNTDQA m128 xmm 7781// Construct and append a MOVNTDQA instruction to the active function. 7782func (c *Context) MOVNTDQA(m, x operand.Op) { 7783 if inst, err := x86.MOVNTDQA(m, x); err == nil { 7784 c.Instruction(inst) 7785 } else { 7786 c.adderror(err) 7787 } 7788} 7789 7790// MOVNTDQA: Load Double Quadword Non-Temporal Aligned Hint. 7791// 7792// Forms: 7793// 7794// MOVNTDQA m128 xmm 7795// Construct and append a MOVNTDQA instruction to the active function. 7796// Operates on the global context. 7797func MOVNTDQA(m, x operand.Op) { ctx.MOVNTDQA(m, x) } 7798 7799// MOVNTIL: Store Doubleword Using Non-Temporal Hint. 7800// 7801// Forms: 7802// 7803// MOVNTIL r32 m32 7804// Construct and append a MOVNTIL instruction to the active function. 7805func (c *Context) MOVNTIL(r, m operand.Op) { 7806 if inst, err := x86.MOVNTIL(r, m); err == nil { 7807 c.Instruction(inst) 7808 } else { 7809 c.adderror(err) 7810 } 7811} 7812 7813// MOVNTIL: Store Doubleword Using Non-Temporal Hint. 7814// 7815// Forms: 7816// 7817// MOVNTIL r32 m32 7818// Construct and append a MOVNTIL instruction to the active function. 7819// Operates on the global context. 7820func MOVNTIL(r, m operand.Op) { ctx.MOVNTIL(r, m) } 7821 7822// MOVNTIQ: Store Doubleword Using Non-Temporal Hint. 7823// 7824// Forms: 7825// 7826// MOVNTIQ r64 m64 7827// Construct and append a MOVNTIQ instruction to the active function. 7828func (c *Context) MOVNTIQ(r, m operand.Op) { 7829 if inst, err := x86.MOVNTIQ(r, m); err == nil { 7830 c.Instruction(inst) 7831 } else { 7832 c.adderror(err) 7833 } 7834} 7835 7836// MOVNTIQ: Store Doubleword Using Non-Temporal Hint. 7837// 7838// Forms: 7839// 7840// MOVNTIQ r64 m64 7841// Construct and append a MOVNTIQ instruction to the active function. 7842// Operates on the global context. 7843func MOVNTIQ(r, m operand.Op) { ctx.MOVNTIQ(r, m) } 7844 7845// MOVNTO: Store Double Quadword Using Non-Temporal Hint. 7846// 7847// Forms: 7848// 7849// MOVNTO xmm m128 7850// Construct and append a MOVNTO instruction to the active function. 7851func (c *Context) MOVNTO(x, m operand.Op) { 7852 if inst, err := x86.MOVNTO(x, m); err == nil { 7853 c.Instruction(inst) 7854 } else { 7855 c.adderror(err) 7856 } 7857} 7858 7859// MOVNTO: Store Double Quadword Using Non-Temporal Hint. 7860// 7861// Forms: 7862// 7863// MOVNTO xmm m128 7864// Construct and append a MOVNTO instruction to the active function. 7865// Operates on the global context. 7866func MOVNTO(x, m operand.Op) { ctx.MOVNTO(x, m) } 7867 7868// MOVNTPD: Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint. 7869// 7870// Forms: 7871// 7872// MOVNTPD xmm m128 7873// Construct and append a MOVNTPD instruction to the active function. 7874func (c *Context) MOVNTPD(x, m operand.Op) { 7875 if inst, err := x86.MOVNTPD(x, m); err == nil { 7876 c.Instruction(inst) 7877 } else { 7878 c.adderror(err) 7879 } 7880} 7881 7882// MOVNTPD: Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint. 7883// 7884// Forms: 7885// 7886// MOVNTPD xmm m128 7887// Construct and append a MOVNTPD instruction to the active function. 7888// Operates on the global context. 7889func MOVNTPD(x, m operand.Op) { ctx.MOVNTPD(x, m) } 7890 7891// MOVNTPS: Store Packed Single-Precision Floating-Point Values Using Non-Temporal Hint. 7892// 7893// Forms: 7894// 7895// MOVNTPS xmm m128 7896// Construct and append a MOVNTPS instruction to the active function. 7897func (c *Context) MOVNTPS(x, m operand.Op) { 7898 if inst, err := x86.MOVNTPS(x, m); err == nil { 7899 c.Instruction(inst) 7900 } else { 7901 c.adderror(err) 7902 } 7903} 7904 7905// MOVNTPS: Store Packed Single-Precision Floating-Point Values Using Non-Temporal Hint. 7906// 7907// Forms: 7908// 7909// MOVNTPS xmm m128 7910// Construct and append a MOVNTPS instruction to the active function. 7911// Operates on the global context. 7912func MOVNTPS(x, m operand.Op) { ctx.MOVNTPS(x, m) } 7913 7914// MOVO: Move Aligned Double Quadword. 7915// 7916// Forms: 7917// 7918// MOVO xmm xmm 7919// MOVO m128 xmm 7920// MOVO xmm m128 7921// Construct and append a MOVO instruction to the active function. 7922func (c *Context) MOVO(mx, mx1 operand.Op) { 7923 if inst, err := x86.MOVO(mx, mx1); err == nil { 7924 c.Instruction(inst) 7925 } else { 7926 c.adderror(err) 7927 } 7928} 7929 7930// MOVO: Move Aligned Double Quadword. 7931// 7932// Forms: 7933// 7934// MOVO xmm xmm 7935// MOVO m128 xmm 7936// MOVO xmm m128 7937// Construct and append a MOVO instruction to the active function. 7938// Operates on the global context. 7939func MOVO(mx, mx1 operand.Op) { ctx.MOVO(mx, mx1) } 7940 7941// MOVOA: Move Aligned Double Quadword. 7942// 7943// Forms: 7944// 7945// MOVOA xmm xmm 7946// MOVOA m128 xmm 7947// MOVOA xmm m128 7948// Construct and append a MOVOA instruction to the active function. 7949func (c *Context) MOVOA(mx, mx1 operand.Op) { 7950 if inst, err := x86.MOVOA(mx, mx1); err == nil { 7951 c.Instruction(inst) 7952 } else { 7953 c.adderror(err) 7954 } 7955} 7956 7957// MOVOA: Move Aligned Double Quadword. 7958// 7959// Forms: 7960// 7961// MOVOA xmm xmm 7962// MOVOA m128 xmm 7963// MOVOA xmm m128 7964// Construct and append a MOVOA instruction to the active function. 7965// Operates on the global context. 7966func MOVOA(mx, mx1 operand.Op) { ctx.MOVOA(mx, mx1) } 7967 7968// MOVOU: Move Unaligned Double Quadword. 7969// 7970// Forms: 7971// 7972// MOVOU xmm xmm 7973// MOVOU m128 xmm 7974// MOVOU xmm m128 7975// Construct and append a MOVOU instruction to the active function. 7976func (c *Context) MOVOU(mx, mx1 operand.Op) { 7977 if inst, err := x86.MOVOU(mx, mx1); err == nil { 7978 c.Instruction(inst) 7979 } else { 7980 c.adderror(err) 7981 } 7982} 7983 7984// MOVOU: Move Unaligned Double Quadword. 7985// 7986// Forms: 7987// 7988// MOVOU xmm xmm 7989// MOVOU m128 xmm 7990// MOVOU xmm m128 7991// Construct and append a MOVOU instruction to the active function. 7992// Operates on the global context. 7993func MOVOU(mx, mx1 operand.Op) { ctx.MOVOU(mx, mx1) } 7994 7995// MOVQ: Move. 7996// 7997// Forms: 7998// 7999// MOVQ imm32 r64 8000// MOVQ imm64 r64 8001// MOVQ r64 r64 8002// MOVQ m64 r64 8003// MOVQ imm32 m64 8004// MOVQ r64 m64 8005// MOVQ xmm r64 8006// MOVQ r64 xmm 8007// MOVQ xmm xmm 8008// MOVQ m64 xmm 8009// MOVQ xmm m64 8010// MOVQ xmm r32 8011// MOVQ r32 xmm 8012// MOVQ m32 xmm 8013// MOVQ xmm m32 8014// Construct and append a MOVQ instruction to the active function. 8015func (c *Context) MOVQ(imrx, mrx operand.Op) { 8016 if inst, err := x86.MOVQ(imrx, mrx); err == nil { 8017 c.Instruction(inst) 8018 } else { 8019 c.adderror(err) 8020 } 8021} 8022 8023// MOVQ: Move. 8024// 8025// Forms: 8026// 8027// MOVQ imm32 r64 8028// MOVQ imm64 r64 8029// MOVQ r64 r64 8030// MOVQ m64 r64 8031// MOVQ imm32 m64 8032// MOVQ r64 m64 8033// MOVQ xmm r64 8034// MOVQ r64 xmm 8035// MOVQ xmm xmm 8036// MOVQ m64 xmm 8037// MOVQ xmm m64 8038// MOVQ xmm r32 8039// MOVQ r32 xmm 8040// MOVQ m32 xmm 8041// MOVQ xmm m32 8042// Construct and append a MOVQ instruction to the active function. 8043// Operates on the global context. 8044func MOVQ(imrx, mrx operand.Op) { ctx.MOVQ(imrx, mrx) } 8045 8046// MOVSD: Move Scalar Double-Precision Floating-Point Value. 8047// 8048// Forms: 8049// 8050// MOVSD xmm xmm 8051// MOVSD m64 xmm 8052// MOVSD xmm m64 8053// Construct and append a MOVSD instruction to the active function. 8054func (c *Context) MOVSD(mx, mx1 operand.Op) { 8055 if inst, err := x86.MOVSD(mx, mx1); err == nil { 8056 c.Instruction(inst) 8057 } else { 8058 c.adderror(err) 8059 } 8060} 8061 8062// MOVSD: Move Scalar Double-Precision Floating-Point Value. 8063// 8064// Forms: 8065// 8066// MOVSD xmm xmm 8067// MOVSD m64 xmm 8068// MOVSD xmm m64 8069// Construct and append a MOVSD instruction to the active function. 8070// Operates on the global context. 8071func MOVSD(mx, mx1 operand.Op) { ctx.MOVSD(mx, mx1) } 8072 8073// MOVSHDUP: Move Packed Single-FP High and Duplicate. 8074// 8075// Forms: 8076// 8077// MOVSHDUP xmm xmm 8078// MOVSHDUP m128 xmm 8079// Construct and append a MOVSHDUP instruction to the active function. 8080func (c *Context) MOVSHDUP(mx, x operand.Op) { 8081 if inst, err := x86.MOVSHDUP(mx, x); err == nil { 8082 c.Instruction(inst) 8083 } else { 8084 c.adderror(err) 8085 } 8086} 8087 8088// MOVSHDUP: Move Packed Single-FP High and Duplicate. 8089// 8090// Forms: 8091// 8092// MOVSHDUP xmm xmm 8093// MOVSHDUP m128 xmm 8094// Construct and append a MOVSHDUP instruction to the active function. 8095// Operates on the global context. 8096func MOVSHDUP(mx, x operand.Op) { ctx.MOVSHDUP(mx, x) } 8097 8098// MOVSLDUP: Move Packed Single-FP Low and Duplicate. 8099// 8100// Forms: 8101// 8102// MOVSLDUP xmm xmm 8103// MOVSLDUP m128 xmm 8104// Construct and append a MOVSLDUP instruction to the active function. 8105func (c *Context) MOVSLDUP(mx, x operand.Op) { 8106 if inst, err := x86.MOVSLDUP(mx, x); err == nil { 8107 c.Instruction(inst) 8108 } else { 8109 c.adderror(err) 8110 } 8111} 8112 8113// MOVSLDUP: Move Packed Single-FP Low and Duplicate. 8114// 8115// Forms: 8116// 8117// MOVSLDUP xmm xmm 8118// MOVSLDUP m128 xmm 8119// Construct and append a MOVSLDUP instruction to the active function. 8120// Operates on the global context. 8121func MOVSLDUP(mx, x operand.Op) { ctx.MOVSLDUP(mx, x) } 8122 8123// MOVSS: Move Scalar Single-Precision Floating-Point Values. 8124// 8125// Forms: 8126// 8127// MOVSS xmm xmm 8128// MOVSS m32 xmm 8129// MOVSS xmm m32 8130// Construct and append a MOVSS instruction to the active function. 8131func (c *Context) MOVSS(mx, mx1 operand.Op) { 8132 if inst, err := x86.MOVSS(mx, mx1); err == nil { 8133 c.Instruction(inst) 8134 } else { 8135 c.adderror(err) 8136 } 8137} 8138 8139// MOVSS: Move Scalar Single-Precision Floating-Point Values. 8140// 8141// Forms: 8142// 8143// MOVSS xmm xmm 8144// MOVSS m32 xmm 8145// MOVSS xmm m32 8146// Construct and append a MOVSS instruction to the active function. 8147// Operates on the global context. 8148func MOVSS(mx, mx1 operand.Op) { ctx.MOVSS(mx, mx1) } 8149 8150// MOVUPD: Move Unaligned Packed Double-Precision Floating-Point Values. 8151// 8152// Forms: 8153// 8154// MOVUPD xmm xmm 8155// MOVUPD m128 xmm 8156// MOVUPD xmm m128 8157// Construct and append a MOVUPD instruction to the active function. 8158func (c *Context) MOVUPD(mx, mx1 operand.Op) { 8159 if inst, err := x86.MOVUPD(mx, mx1); err == nil { 8160 c.Instruction(inst) 8161 } else { 8162 c.adderror(err) 8163 } 8164} 8165 8166// MOVUPD: Move Unaligned Packed Double-Precision Floating-Point Values. 8167// 8168// Forms: 8169// 8170// MOVUPD xmm xmm 8171// MOVUPD m128 xmm 8172// MOVUPD xmm m128 8173// Construct and append a MOVUPD instruction to the active function. 8174// Operates on the global context. 8175func MOVUPD(mx, mx1 operand.Op) { ctx.MOVUPD(mx, mx1) } 8176 8177// MOVUPS: Move Unaligned Packed Single-Precision Floating-Point Values. 8178// 8179// Forms: 8180// 8181// MOVUPS xmm xmm 8182// MOVUPS m128 xmm 8183// MOVUPS xmm m128 8184// Construct and append a MOVUPS instruction to the active function. 8185func (c *Context) MOVUPS(mx, mx1 operand.Op) { 8186 if inst, err := x86.MOVUPS(mx, mx1); err == nil { 8187 c.Instruction(inst) 8188 } else { 8189 c.adderror(err) 8190 } 8191} 8192 8193// MOVUPS: Move Unaligned Packed Single-Precision Floating-Point Values. 8194// 8195// Forms: 8196// 8197// MOVUPS xmm xmm 8198// MOVUPS m128 xmm 8199// MOVUPS xmm m128 8200// Construct and append a MOVUPS instruction to the active function. 8201// Operates on the global context. 8202func MOVUPS(mx, mx1 operand.Op) { ctx.MOVUPS(mx, mx1) } 8203 8204// MOVW: Move. 8205// 8206// Forms: 8207// 8208// MOVW imm16 r16 8209// MOVW r16 r16 8210// MOVW m16 r16 8211// MOVW imm16 m16 8212// MOVW r16 m16 8213// Construct and append a MOVW instruction to the active function. 8214func (c *Context) MOVW(imr, mr operand.Op) { 8215 if inst, err := x86.MOVW(imr, mr); err == nil { 8216 c.Instruction(inst) 8217 } else { 8218 c.adderror(err) 8219 } 8220} 8221 8222// MOVW: Move. 8223// 8224// Forms: 8225// 8226// MOVW imm16 r16 8227// MOVW r16 r16 8228// MOVW m16 r16 8229// MOVW imm16 m16 8230// MOVW r16 m16 8231// Construct and append a MOVW instruction to the active function. 8232// Operates on the global context. 8233func MOVW(imr, mr operand.Op) { ctx.MOVW(imr, mr) } 8234 8235// MOVWLSX: Move with Sign-Extension. 8236// 8237// Forms: 8238// 8239// MOVWLSX r16 r32 8240// MOVWLSX m16 r32 8241// Construct and append a MOVWLSX instruction to the active function. 8242func (c *Context) MOVWLSX(mr, r operand.Op) { 8243 if inst, err := x86.MOVWLSX(mr, r); err == nil { 8244 c.Instruction(inst) 8245 } else { 8246 c.adderror(err) 8247 } 8248} 8249 8250// MOVWLSX: Move with Sign-Extension. 8251// 8252// Forms: 8253// 8254// MOVWLSX r16 r32 8255// MOVWLSX m16 r32 8256// Construct and append a MOVWLSX instruction to the active function. 8257// Operates on the global context. 8258func MOVWLSX(mr, r operand.Op) { ctx.MOVWLSX(mr, r) } 8259 8260// MOVWLZX: Move with Zero-Extend. 8261// 8262// Forms: 8263// 8264// MOVWLZX r16 r32 8265// MOVWLZX m16 r32 8266// Construct and append a MOVWLZX instruction to the active function. 8267func (c *Context) MOVWLZX(mr, r operand.Op) { 8268 if inst, err := x86.MOVWLZX(mr, r); err == nil { 8269 c.Instruction(inst) 8270 } else { 8271 c.adderror(err) 8272 } 8273} 8274 8275// MOVWLZX: Move with Zero-Extend. 8276// 8277// Forms: 8278// 8279// MOVWLZX r16 r32 8280// MOVWLZX m16 r32 8281// Construct and append a MOVWLZX instruction to the active function. 8282// Operates on the global context. 8283func MOVWLZX(mr, r operand.Op) { ctx.MOVWLZX(mr, r) } 8284 8285// MOVWQSX: Move with Sign-Extension. 8286// 8287// Forms: 8288// 8289// MOVWQSX r16 r64 8290// MOVWQSX m16 r64 8291// Construct and append a MOVWQSX instruction to the active function. 8292func (c *Context) MOVWQSX(mr, r operand.Op) { 8293 if inst, err := x86.MOVWQSX(mr, r); err == nil { 8294 c.Instruction(inst) 8295 } else { 8296 c.adderror(err) 8297 } 8298} 8299 8300// MOVWQSX: Move with Sign-Extension. 8301// 8302// Forms: 8303// 8304// MOVWQSX r16 r64 8305// MOVWQSX m16 r64 8306// Construct and append a MOVWQSX instruction to the active function. 8307// Operates on the global context. 8308func MOVWQSX(mr, r operand.Op) { ctx.MOVWQSX(mr, r) } 8309 8310// MOVWQZX: Move with Zero-Extend. 8311// 8312// Forms: 8313// 8314// MOVWQZX r16 r64 8315// MOVWQZX m16 r64 8316// Construct and append a MOVWQZX instruction to the active function. 8317func (c *Context) MOVWQZX(mr, r operand.Op) { 8318 if inst, err := x86.MOVWQZX(mr, r); err == nil { 8319 c.Instruction(inst) 8320 } else { 8321 c.adderror(err) 8322 } 8323} 8324 8325// MOVWQZX: Move with Zero-Extend. 8326// 8327// Forms: 8328// 8329// MOVWQZX r16 r64 8330// MOVWQZX m16 r64 8331// Construct and append a MOVWQZX instruction to the active function. 8332// Operates on the global context. 8333func MOVWQZX(mr, r operand.Op) { ctx.MOVWQZX(mr, r) } 8334 8335// MPSADBW: Compute Multiple Packed Sums of Absolute Difference. 8336// 8337// Forms: 8338// 8339// MPSADBW imm8 xmm xmm 8340// MPSADBW imm8 m128 xmm 8341// Construct and append a MPSADBW instruction to the active function. 8342func (c *Context) MPSADBW(i, mx, x operand.Op) { 8343 if inst, err := x86.MPSADBW(i, mx, x); err == nil { 8344 c.Instruction(inst) 8345 } else { 8346 c.adderror(err) 8347 } 8348} 8349 8350// MPSADBW: Compute Multiple Packed Sums of Absolute Difference. 8351// 8352// Forms: 8353// 8354// MPSADBW imm8 xmm xmm 8355// MPSADBW imm8 m128 xmm 8356// Construct and append a MPSADBW instruction to the active function. 8357// Operates on the global context. 8358func MPSADBW(i, mx, x operand.Op) { ctx.MPSADBW(i, mx, x) } 8359 8360// MULB: Unsigned Multiply. 8361// 8362// Forms: 8363// 8364// MULB r8 8365// MULB m8 8366// Construct and append a MULB instruction to the active function. 8367func (c *Context) MULB(mr operand.Op) { 8368 if inst, err := x86.MULB(mr); err == nil { 8369 c.Instruction(inst) 8370 } else { 8371 c.adderror(err) 8372 } 8373} 8374 8375// MULB: Unsigned Multiply. 8376// 8377// Forms: 8378// 8379// MULB r8 8380// MULB m8 8381// Construct and append a MULB instruction to the active function. 8382// Operates on the global context. 8383func MULB(mr operand.Op) { ctx.MULB(mr) } 8384 8385// MULL: Unsigned Multiply. 8386// 8387// Forms: 8388// 8389// MULL r32 8390// MULL m32 8391// Construct and append a MULL instruction to the active function. 8392func (c *Context) MULL(mr operand.Op) { 8393 if inst, err := x86.MULL(mr); err == nil { 8394 c.Instruction(inst) 8395 } else { 8396 c.adderror(err) 8397 } 8398} 8399 8400// MULL: Unsigned Multiply. 8401// 8402// Forms: 8403// 8404// MULL r32 8405// MULL m32 8406// Construct and append a MULL instruction to the active function. 8407// Operates on the global context. 8408func MULL(mr operand.Op) { ctx.MULL(mr) } 8409 8410// MULPD: Multiply Packed Double-Precision Floating-Point Values. 8411// 8412// Forms: 8413// 8414// MULPD xmm xmm 8415// MULPD m128 xmm 8416// Construct and append a MULPD instruction to the active function. 8417func (c *Context) MULPD(mx, x operand.Op) { 8418 if inst, err := x86.MULPD(mx, x); err == nil { 8419 c.Instruction(inst) 8420 } else { 8421 c.adderror(err) 8422 } 8423} 8424 8425// MULPD: Multiply Packed Double-Precision Floating-Point Values. 8426// 8427// Forms: 8428// 8429// MULPD xmm xmm 8430// MULPD m128 xmm 8431// Construct and append a MULPD instruction to the active function. 8432// Operates on the global context. 8433func MULPD(mx, x operand.Op) { ctx.MULPD(mx, x) } 8434 8435// MULPS: Multiply Packed Single-Precision Floating-Point Values. 8436// 8437// Forms: 8438// 8439// MULPS xmm xmm 8440// MULPS m128 xmm 8441// Construct and append a MULPS instruction to the active function. 8442func (c *Context) MULPS(mx, x operand.Op) { 8443 if inst, err := x86.MULPS(mx, x); err == nil { 8444 c.Instruction(inst) 8445 } else { 8446 c.adderror(err) 8447 } 8448} 8449 8450// MULPS: Multiply Packed Single-Precision Floating-Point Values. 8451// 8452// Forms: 8453// 8454// MULPS xmm xmm 8455// MULPS m128 xmm 8456// Construct and append a MULPS instruction to the active function. 8457// Operates on the global context. 8458func MULPS(mx, x operand.Op) { ctx.MULPS(mx, x) } 8459 8460// MULQ: Unsigned Multiply. 8461// 8462// Forms: 8463// 8464// MULQ r64 8465// MULQ m64 8466// Construct and append a MULQ instruction to the active function. 8467func (c *Context) MULQ(mr operand.Op) { 8468 if inst, err := x86.MULQ(mr); err == nil { 8469 c.Instruction(inst) 8470 } else { 8471 c.adderror(err) 8472 } 8473} 8474 8475// MULQ: Unsigned Multiply. 8476// 8477// Forms: 8478// 8479// MULQ r64 8480// MULQ m64 8481// Construct and append a MULQ instruction to the active function. 8482// Operates on the global context. 8483func MULQ(mr operand.Op) { ctx.MULQ(mr) } 8484 8485// MULSD: Multiply Scalar Double-Precision Floating-Point Values. 8486// 8487// Forms: 8488// 8489// MULSD xmm xmm 8490// MULSD m64 xmm 8491// Construct and append a MULSD instruction to the active function. 8492func (c *Context) MULSD(mx, x operand.Op) { 8493 if inst, err := x86.MULSD(mx, x); err == nil { 8494 c.Instruction(inst) 8495 } else { 8496 c.adderror(err) 8497 } 8498} 8499 8500// MULSD: Multiply Scalar Double-Precision Floating-Point Values. 8501// 8502// Forms: 8503// 8504// MULSD xmm xmm 8505// MULSD m64 xmm 8506// Construct and append a MULSD instruction to the active function. 8507// Operates on the global context. 8508func MULSD(mx, x operand.Op) { ctx.MULSD(mx, x) } 8509 8510// MULSS: Multiply Scalar Single-Precision Floating-Point Values. 8511// 8512// Forms: 8513// 8514// MULSS xmm xmm 8515// MULSS m32 xmm 8516// Construct and append a MULSS instruction to the active function. 8517func (c *Context) MULSS(mx, x operand.Op) { 8518 if inst, err := x86.MULSS(mx, x); err == nil { 8519 c.Instruction(inst) 8520 } else { 8521 c.adderror(err) 8522 } 8523} 8524 8525// MULSS: Multiply Scalar Single-Precision Floating-Point Values. 8526// 8527// Forms: 8528// 8529// MULSS xmm xmm 8530// MULSS m32 xmm 8531// Construct and append a MULSS instruction to the active function. 8532// Operates on the global context. 8533func MULSS(mx, x operand.Op) { ctx.MULSS(mx, x) } 8534 8535// MULW: Unsigned Multiply. 8536// 8537// Forms: 8538// 8539// MULW r16 8540// MULW m16 8541// Construct and append a MULW instruction to the active function. 8542func (c *Context) MULW(mr operand.Op) { 8543 if inst, err := x86.MULW(mr); err == nil { 8544 c.Instruction(inst) 8545 } else { 8546 c.adderror(err) 8547 } 8548} 8549 8550// MULW: Unsigned Multiply. 8551// 8552// Forms: 8553// 8554// MULW r16 8555// MULW m16 8556// Construct and append a MULW instruction to the active function. 8557// Operates on the global context. 8558func MULW(mr operand.Op) { ctx.MULW(mr) } 8559 8560// MULXL: Unsigned Multiply Without Affecting Flags. 8561// 8562// Forms: 8563// 8564// MULXL r32 r32 r32 8565// MULXL m32 r32 r32 8566// Construct and append a MULXL instruction to the active function. 8567func (c *Context) MULXL(mr, r, r1 operand.Op) { 8568 if inst, err := x86.MULXL(mr, r, r1); err == nil { 8569 c.Instruction(inst) 8570 } else { 8571 c.adderror(err) 8572 } 8573} 8574 8575// MULXL: Unsigned Multiply Without Affecting Flags. 8576// 8577// Forms: 8578// 8579// MULXL r32 r32 r32 8580// MULXL m32 r32 r32 8581// Construct and append a MULXL instruction to the active function. 8582// Operates on the global context. 8583func MULXL(mr, r, r1 operand.Op) { ctx.MULXL(mr, r, r1) } 8584 8585// MULXQ: Unsigned Multiply Without Affecting Flags. 8586// 8587// Forms: 8588// 8589// MULXQ r64 r64 r64 8590// MULXQ m64 r64 r64 8591// Construct and append a MULXQ instruction to the active function. 8592func (c *Context) MULXQ(mr, r, r1 operand.Op) { 8593 if inst, err := x86.MULXQ(mr, r, r1); err == nil { 8594 c.Instruction(inst) 8595 } else { 8596 c.adderror(err) 8597 } 8598} 8599 8600// MULXQ: Unsigned Multiply Without Affecting Flags. 8601// 8602// Forms: 8603// 8604// MULXQ r64 r64 r64 8605// MULXQ m64 r64 r64 8606// Construct and append a MULXQ instruction to the active function. 8607// Operates on the global context. 8608func MULXQ(mr, r, r1 operand.Op) { ctx.MULXQ(mr, r, r1) } 8609 8610// MWAIT: Monitor Wait. 8611// 8612// Forms: 8613// 8614// MWAIT 8615// Construct and append a MWAIT instruction to the active function. 8616func (c *Context) MWAIT() { 8617 if inst, err := x86.MWAIT(); err == nil { 8618 c.Instruction(inst) 8619 } else { 8620 c.adderror(err) 8621 } 8622} 8623 8624// MWAIT: Monitor Wait. 8625// 8626// Forms: 8627// 8628// MWAIT 8629// Construct and append a MWAIT instruction to the active function. 8630// Operates on the global context. 8631func MWAIT() { ctx.MWAIT() } 8632 8633// NEGB: Two's Complement Negation. 8634// 8635// Forms: 8636// 8637// NEGB r8 8638// NEGB m8 8639// Construct and append a NEGB instruction to the active function. 8640func (c *Context) NEGB(mr operand.Op) { 8641 if inst, err := x86.NEGB(mr); err == nil { 8642 c.Instruction(inst) 8643 } else { 8644 c.adderror(err) 8645 } 8646} 8647 8648// NEGB: Two's Complement Negation. 8649// 8650// Forms: 8651// 8652// NEGB r8 8653// NEGB m8 8654// Construct and append a NEGB instruction to the active function. 8655// Operates on the global context. 8656func NEGB(mr operand.Op) { ctx.NEGB(mr) } 8657 8658// NEGL: Two's Complement Negation. 8659// 8660// Forms: 8661// 8662// NEGL r32 8663// NEGL m32 8664// Construct and append a NEGL instruction to the active function. 8665func (c *Context) NEGL(mr operand.Op) { 8666 if inst, err := x86.NEGL(mr); err == nil { 8667 c.Instruction(inst) 8668 } else { 8669 c.adderror(err) 8670 } 8671} 8672 8673// NEGL: Two's Complement Negation. 8674// 8675// Forms: 8676// 8677// NEGL r32 8678// NEGL m32 8679// Construct and append a NEGL instruction to the active function. 8680// Operates on the global context. 8681func NEGL(mr operand.Op) { ctx.NEGL(mr) } 8682 8683// NEGQ: Two's Complement Negation. 8684// 8685// Forms: 8686// 8687// NEGQ r64 8688// NEGQ m64 8689// Construct and append a NEGQ instruction to the active function. 8690func (c *Context) NEGQ(mr operand.Op) { 8691 if inst, err := x86.NEGQ(mr); err == nil { 8692 c.Instruction(inst) 8693 } else { 8694 c.adderror(err) 8695 } 8696} 8697 8698// NEGQ: Two's Complement Negation. 8699// 8700// Forms: 8701// 8702// NEGQ r64 8703// NEGQ m64 8704// Construct and append a NEGQ instruction to the active function. 8705// Operates on the global context. 8706func NEGQ(mr operand.Op) { ctx.NEGQ(mr) } 8707 8708// NEGW: Two's Complement Negation. 8709// 8710// Forms: 8711// 8712// NEGW r16 8713// NEGW m16 8714// Construct and append a NEGW instruction to the active function. 8715func (c *Context) NEGW(mr operand.Op) { 8716 if inst, err := x86.NEGW(mr); err == nil { 8717 c.Instruction(inst) 8718 } else { 8719 c.adderror(err) 8720 } 8721} 8722 8723// NEGW: Two's Complement Negation. 8724// 8725// Forms: 8726// 8727// NEGW r16 8728// NEGW m16 8729// Construct and append a NEGW instruction to the active function. 8730// Operates on the global context. 8731func NEGW(mr operand.Op) { ctx.NEGW(mr) } 8732 8733// NOP: No Operation. 8734// 8735// Forms: 8736// 8737// NOP 8738// Construct and append a NOP instruction to the active function. 8739func (c *Context) NOP() { 8740 if inst, err := x86.NOP(); err == nil { 8741 c.Instruction(inst) 8742 } else { 8743 c.adderror(err) 8744 } 8745} 8746 8747// NOP: No Operation. 8748// 8749// Forms: 8750// 8751// NOP 8752// Construct and append a NOP instruction to the active function. 8753// Operates on the global context. 8754func NOP() { ctx.NOP() } 8755 8756// NOTB: One's Complement Negation. 8757// 8758// Forms: 8759// 8760// NOTB r8 8761// NOTB m8 8762// Construct and append a NOTB instruction to the active function. 8763func (c *Context) NOTB(mr operand.Op) { 8764 if inst, err := x86.NOTB(mr); err == nil { 8765 c.Instruction(inst) 8766 } else { 8767 c.adderror(err) 8768 } 8769} 8770 8771// NOTB: One's Complement Negation. 8772// 8773// Forms: 8774// 8775// NOTB r8 8776// NOTB m8 8777// Construct and append a NOTB instruction to the active function. 8778// Operates on the global context. 8779func NOTB(mr operand.Op) { ctx.NOTB(mr) } 8780 8781// NOTL: One's Complement Negation. 8782// 8783// Forms: 8784// 8785// NOTL r32 8786// NOTL m32 8787// Construct and append a NOTL instruction to the active function. 8788func (c *Context) NOTL(mr operand.Op) { 8789 if inst, err := x86.NOTL(mr); err == nil { 8790 c.Instruction(inst) 8791 } else { 8792 c.adderror(err) 8793 } 8794} 8795 8796// NOTL: One's Complement Negation. 8797// 8798// Forms: 8799// 8800// NOTL r32 8801// NOTL m32 8802// Construct and append a NOTL instruction to the active function. 8803// Operates on the global context. 8804func NOTL(mr operand.Op) { ctx.NOTL(mr) } 8805 8806// NOTQ: One's Complement Negation. 8807// 8808// Forms: 8809// 8810// NOTQ r64 8811// NOTQ m64 8812// Construct and append a NOTQ instruction to the active function. 8813func (c *Context) NOTQ(mr operand.Op) { 8814 if inst, err := x86.NOTQ(mr); err == nil { 8815 c.Instruction(inst) 8816 } else { 8817 c.adderror(err) 8818 } 8819} 8820 8821// NOTQ: One's Complement Negation. 8822// 8823// Forms: 8824// 8825// NOTQ r64 8826// NOTQ m64 8827// Construct and append a NOTQ instruction to the active function. 8828// Operates on the global context. 8829func NOTQ(mr operand.Op) { ctx.NOTQ(mr) } 8830 8831// NOTW: One's Complement Negation. 8832// 8833// Forms: 8834// 8835// NOTW r16 8836// NOTW m16 8837// Construct and append a NOTW instruction to the active function. 8838func (c *Context) NOTW(mr operand.Op) { 8839 if inst, err := x86.NOTW(mr); err == nil { 8840 c.Instruction(inst) 8841 } else { 8842 c.adderror(err) 8843 } 8844} 8845 8846// NOTW: One's Complement Negation. 8847// 8848// Forms: 8849// 8850// NOTW r16 8851// NOTW m16 8852// Construct and append a NOTW instruction to the active function. 8853// Operates on the global context. 8854func NOTW(mr operand.Op) { ctx.NOTW(mr) } 8855 8856// ORB: Logical Inclusive OR. 8857// 8858// Forms: 8859// 8860// ORB imm8 al 8861// ORB imm8 r8 8862// ORB r8 r8 8863// ORB m8 r8 8864// ORB imm8 m8 8865// ORB r8 m8 8866// Construct and append a ORB instruction to the active function. 8867func (c *Context) ORB(imr, amr operand.Op) { 8868 if inst, err := x86.ORB(imr, amr); err == nil { 8869 c.Instruction(inst) 8870 } else { 8871 c.adderror(err) 8872 } 8873} 8874 8875// ORB: Logical Inclusive OR. 8876// 8877// Forms: 8878// 8879// ORB imm8 al 8880// ORB imm8 r8 8881// ORB r8 r8 8882// ORB m8 r8 8883// ORB imm8 m8 8884// ORB r8 m8 8885// Construct and append a ORB instruction to the active function. 8886// Operates on the global context. 8887func ORB(imr, amr operand.Op) { ctx.ORB(imr, amr) } 8888 8889// ORL: Logical Inclusive OR. 8890// 8891// Forms: 8892// 8893// ORL imm32 eax 8894// ORL imm8 r32 8895// ORL imm32 r32 8896// ORL r32 r32 8897// ORL m32 r32 8898// ORL imm8 m32 8899// ORL imm32 m32 8900// ORL r32 m32 8901// Construct and append a ORL instruction to the active function. 8902func (c *Context) ORL(imr, emr operand.Op) { 8903 if inst, err := x86.ORL(imr, emr); err == nil { 8904 c.Instruction(inst) 8905 } else { 8906 c.adderror(err) 8907 } 8908} 8909 8910// ORL: Logical Inclusive OR. 8911// 8912// Forms: 8913// 8914// ORL imm32 eax 8915// ORL imm8 r32 8916// ORL imm32 r32 8917// ORL r32 r32 8918// ORL m32 r32 8919// ORL imm8 m32 8920// ORL imm32 m32 8921// ORL r32 m32 8922// Construct and append a ORL instruction to the active function. 8923// Operates on the global context. 8924func ORL(imr, emr operand.Op) { ctx.ORL(imr, emr) } 8925 8926// ORPD: Bitwise Logical OR of Double-Precision Floating-Point Values. 8927// 8928// Forms: 8929// 8930// ORPD xmm xmm 8931// ORPD m128 xmm 8932// Construct and append a ORPD instruction to the active function. 8933func (c *Context) ORPD(mx, x operand.Op) { 8934 if inst, err := x86.ORPD(mx, x); err == nil { 8935 c.Instruction(inst) 8936 } else { 8937 c.adderror(err) 8938 } 8939} 8940 8941// ORPD: Bitwise Logical OR of Double-Precision Floating-Point Values. 8942// 8943// Forms: 8944// 8945// ORPD xmm xmm 8946// ORPD m128 xmm 8947// Construct and append a ORPD instruction to the active function. 8948// Operates on the global context. 8949func ORPD(mx, x operand.Op) { ctx.ORPD(mx, x) } 8950 8951// ORPS: Bitwise Logical OR of Single-Precision Floating-Point Values. 8952// 8953// Forms: 8954// 8955// ORPS xmm xmm 8956// ORPS m128 xmm 8957// Construct and append a ORPS instruction to the active function. 8958func (c *Context) ORPS(mx, x operand.Op) { 8959 if inst, err := x86.ORPS(mx, x); err == nil { 8960 c.Instruction(inst) 8961 } else { 8962 c.adderror(err) 8963 } 8964} 8965 8966// ORPS: Bitwise Logical OR of Single-Precision Floating-Point Values. 8967// 8968// Forms: 8969// 8970// ORPS xmm xmm 8971// ORPS m128 xmm 8972// Construct and append a ORPS instruction to the active function. 8973// Operates on the global context. 8974func ORPS(mx, x operand.Op) { ctx.ORPS(mx, x) } 8975 8976// ORQ: Logical Inclusive OR. 8977// 8978// Forms: 8979// 8980// ORQ imm32 rax 8981// ORQ imm8 r64 8982// ORQ imm32 r64 8983// ORQ r64 r64 8984// ORQ m64 r64 8985// ORQ imm8 m64 8986// ORQ imm32 m64 8987// ORQ r64 m64 8988// Construct and append a ORQ instruction to the active function. 8989func (c *Context) ORQ(imr, mr operand.Op) { 8990 if inst, err := x86.ORQ(imr, mr); err == nil { 8991 c.Instruction(inst) 8992 } else { 8993 c.adderror(err) 8994 } 8995} 8996 8997// ORQ: Logical Inclusive OR. 8998// 8999// Forms: 9000// 9001// ORQ imm32 rax 9002// ORQ imm8 r64 9003// ORQ imm32 r64 9004// ORQ r64 r64 9005// ORQ m64 r64 9006// ORQ imm8 m64 9007// ORQ imm32 m64 9008// ORQ r64 m64 9009// Construct and append a ORQ instruction to the active function. 9010// Operates on the global context. 9011func ORQ(imr, mr operand.Op) { ctx.ORQ(imr, mr) } 9012 9013// ORW: Logical Inclusive OR. 9014// 9015// Forms: 9016// 9017// ORW imm16 ax 9018// ORW imm8 r16 9019// ORW imm16 r16 9020// ORW r16 r16 9021// ORW m16 r16 9022// ORW imm8 m16 9023// ORW imm16 m16 9024// ORW r16 m16 9025// Construct and append a ORW instruction to the active function. 9026func (c *Context) ORW(imr, amr operand.Op) { 9027 if inst, err := x86.ORW(imr, amr); err == nil { 9028 c.Instruction(inst) 9029 } else { 9030 c.adderror(err) 9031 } 9032} 9033 9034// ORW: Logical Inclusive OR. 9035// 9036// Forms: 9037// 9038// ORW imm16 ax 9039// ORW imm8 r16 9040// ORW imm16 r16 9041// ORW r16 r16 9042// ORW m16 r16 9043// ORW imm8 m16 9044// ORW imm16 m16 9045// ORW r16 m16 9046// Construct and append a ORW instruction to the active function. 9047// Operates on the global context. 9048func ORW(imr, amr operand.Op) { ctx.ORW(imr, amr) } 9049 9050// PABSB: Packed Absolute Value of Byte Integers. 9051// 9052// Forms: 9053// 9054// PABSB xmm xmm 9055// PABSB m128 xmm 9056// Construct and append a PABSB instruction to the active function. 9057func (c *Context) PABSB(mx, x operand.Op) { 9058 if inst, err := x86.PABSB(mx, x); err == nil { 9059 c.Instruction(inst) 9060 } else { 9061 c.adderror(err) 9062 } 9063} 9064 9065// PABSB: Packed Absolute Value of Byte Integers. 9066// 9067// Forms: 9068// 9069// PABSB xmm xmm 9070// PABSB m128 xmm 9071// Construct and append a PABSB instruction to the active function. 9072// Operates on the global context. 9073func PABSB(mx, x operand.Op) { ctx.PABSB(mx, x) } 9074 9075// PABSD: Packed Absolute Value of Doubleword Integers. 9076// 9077// Forms: 9078// 9079// PABSD xmm xmm 9080// PABSD m128 xmm 9081// Construct and append a PABSD instruction to the active function. 9082func (c *Context) PABSD(mx, x operand.Op) { 9083 if inst, err := x86.PABSD(mx, x); err == nil { 9084 c.Instruction(inst) 9085 } else { 9086 c.adderror(err) 9087 } 9088} 9089 9090// PABSD: Packed Absolute Value of Doubleword Integers. 9091// 9092// Forms: 9093// 9094// PABSD xmm xmm 9095// PABSD m128 xmm 9096// Construct and append a PABSD instruction to the active function. 9097// Operates on the global context. 9098func PABSD(mx, x operand.Op) { ctx.PABSD(mx, x) } 9099 9100// PABSW: Packed Absolute Value of Word Integers. 9101// 9102// Forms: 9103// 9104// PABSW xmm xmm 9105// PABSW m128 xmm 9106// Construct and append a PABSW instruction to the active function. 9107func (c *Context) PABSW(mx, x operand.Op) { 9108 if inst, err := x86.PABSW(mx, x); err == nil { 9109 c.Instruction(inst) 9110 } else { 9111 c.adderror(err) 9112 } 9113} 9114 9115// PABSW: Packed Absolute Value of Word Integers. 9116// 9117// Forms: 9118// 9119// PABSW xmm xmm 9120// PABSW m128 xmm 9121// Construct and append a PABSW instruction to the active function. 9122// Operates on the global context. 9123func PABSW(mx, x operand.Op) { ctx.PABSW(mx, x) } 9124 9125// PACKSSLW: Pack Doublewords into Words with Signed Saturation. 9126// 9127// Forms: 9128// 9129// PACKSSLW xmm xmm 9130// PACKSSLW m128 xmm 9131// Construct and append a PACKSSLW instruction to the active function. 9132func (c *Context) PACKSSLW(mx, x operand.Op) { 9133 if inst, err := x86.PACKSSLW(mx, x); err == nil { 9134 c.Instruction(inst) 9135 } else { 9136 c.adderror(err) 9137 } 9138} 9139 9140// PACKSSLW: Pack Doublewords into Words with Signed Saturation. 9141// 9142// Forms: 9143// 9144// PACKSSLW xmm xmm 9145// PACKSSLW m128 xmm 9146// Construct and append a PACKSSLW instruction to the active function. 9147// Operates on the global context. 9148func PACKSSLW(mx, x operand.Op) { ctx.PACKSSLW(mx, x) } 9149 9150// PACKSSWB: Pack Words into Bytes with Signed Saturation. 9151// 9152// Forms: 9153// 9154// PACKSSWB xmm xmm 9155// PACKSSWB m128 xmm 9156// Construct and append a PACKSSWB instruction to the active function. 9157func (c *Context) PACKSSWB(mx, x operand.Op) { 9158 if inst, err := x86.PACKSSWB(mx, x); err == nil { 9159 c.Instruction(inst) 9160 } else { 9161 c.adderror(err) 9162 } 9163} 9164 9165// PACKSSWB: Pack Words into Bytes with Signed Saturation. 9166// 9167// Forms: 9168// 9169// PACKSSWB xmm xmm 9170// PACKSSWB m128 xmm 9171// Construct and append a PACKSSWB instruction to the active function. 9172// Operates on the global context. 9173func PACKSSWB(mx, x operand.Op) { ctx.PACKSSWB(mx, x) } 9174 9175// PACKUSDW: Pack Doublewords into Words with Unsigned Saturation. 9176// 9177// Forms: 9178// 9179// PACKUSDW xmm xmm 9180// PACKUSDW m128 xmm 9181// Construct and append a PACKUSDW instruction to the active function. 9182func (c *Context) PACKUSDW(mx, x operand.Op) { 9183 if inst, err := x86.PACKUSDW(mx, x); err == nil { 9184 c.Instruction(inst) 9185 } else { 9186 c.adderror(err) 9187 } 9188} 9189 9190// PACKUSDW: Pack Doublewords into Words with Unsigned Saturation. 9191// 9192// Forms: 9193// 9194// PACKUSDW xmm xmm 9195// PACKUSDW m128 xmm 9196// Construct and append a PACKUSDW instruction to the active function. 9197// Operates on the global context. 9198func PACKUSDW(mx, x operand.Op) { ctx.PACKUSDW(mx, x) } 9199 9200// PACKUSWB: Pack Words into Bytes with Unsigned Saturation. 9201// 9202// Forms: 9203// 9204// PACKUSWB xmm xmm 9205// PACKUSWB m128 xmm 9206// Construct and append a PACKUSWB instruction to the active function. 9207func (c *Context) PACKUSWB(mx, x operand.Op) { 9208 if inst, err := x86.PACKUSWB(mx, x); err == nil { 9209 c.Instruction(inst) 9210 } else { 9211 c.adderror(err) 9212 } 9213} 9214 9215// PACKUSWB: Pack Words into Bytes with Unsigned Saturation. 9216// 9217// Forms: 9218// 9219// PACKUSWB xmm xmm 9220// PACKUSWB m128 xmm 9221// Construct and append a PACKUSWB instruction to the active function. 9222// Operates on the global context. 9223func PACKUSWB(mx, x operand.Op) { ctx.PACKUSWB(mx, x) } 9224 9225// PADDB: Add Packed Byte Integers. 9226// 9227// Forms: 9228// 9229// PADDB xmm xmm 9230// PADDB m128 xmm 9231// Construct and append a PADDB instruction to the active function. 9232func (c *Context) PADDB(mx, x operand.Op) { 9233 if inst, err := x86.PADDB(mx, x); err == nil { 9234 c.Instruction(inst) 9235 } else { 9236 c.adderror(err) 9237 } 9238} 9239 9240// PADDB: Add Packed Byte Integers. 9241// 9242// Forms: 9243// 9244// PADDB xmm xmm 9245// PADDB m128 xmm 9246// Construct and append a PADDB instruction to the active function. 9247// Operates on the global context. 9248func PADDB(mx, x operand.Op) { ctx.PADDB(mx, x) } 9249 9250// PADDD: Add Packed Doubleword Integers. 9251// 9252// Forms: 9253// 9254// PADDD xmm xmm 9255// PADDD m128 xmm 9256// Construct and append a PADDD instruction to the active function. 9257func (c *Context) PADDD(mx, x operand.Op) { 9258 if inst, err := x86.PADDD(mx, x); err == nil { 9259 c.Instruction(inst) 9260 } else { 9261 c.adderror(err) 9262 } 9263} 9264 9265// PADDD: Add Packed Doubleword Integers. 9266// 9267// Forms: 9268// 9269// PADDD xmm xmm 9270// PADDD m128 xmm 9271// Construct and append a PADDD instruction to the active function. 9272// Operates on the global context. 9273func PADDD(mx, x operand.Op) { ctx.PADDD(mx, x) } 9274 9275// PADDL: Add Packed Doubleword Integers. 9276// 9277// Forms: 9278// 9279// PADDL xmm xmm 9280// PADDL m128 xmm 9281// Construct and append a PADDL instruction to the active function. 9282func (c *Context) PADDL(mx, x operand.Op) { 9283 if inst, err := x86.PADDL(mx, x); err == nil { 9284 c.Instruction(inst) 9285 } else { 9286 c.adderror(err) 9287 } 9288} 9289 9290// PADDL: Add Packed Doubleword Integers. 9291// 9292// Forms: 9293// 9294// PADDL xmm xmm 9295// PADDL m128 xmm 9296// Construct and append a PADDL instruction to the active function. 9297// Operates on the global context. 9298func PADDL(mx, x operand.Op) { ctx.PADDL(mx, x) } 9299 9300// PADDQ: Add Packed Quadword Integers. 9301// 9302// Forms: 9303// 9304// PADDQ xmm xmm 9305// PADDQ m128 xmm 9306// Construct and append a PADDQ instruction to the active function. 9307func (c *Context) PADDQ(mx, x operand.Op) { 9308 if inst, err := x86.PADDQ(mx, x); err == nil { 9309 c.Instruction(inst) 9310 } else { 9311 c.adderror(err) 9312 } 9313} 9314 9315// PADDQ: Add Packed Quadword Integers. 9316// 9317// Forms: 9318// 9319// PADDQ xmm xmm 9320// PADDQ m128 xmm 9321// Construct and append a PADDQ instruction to the active function. 9322// Operates on the global context. 9323func PADDQ(mx, x operand.Op) { ctx.PADDQ(mx, x) } 9324 9325// PADDSB: Add Packed Signed Byte Integers with Signed Saturation. 9326// 9327// Forms: 9328// 9329// PADDSB xmm xmm 9330// PADDSB m128 xmm 9331// Construct and append a PADDSB instruction to the active function. 9332func (c *Context) PADDSB(mx, x operand.Op) { 9333 if inst, err := x86.PADDSB(mx, x); err == nil { 9334 c.Instruction(inst) 9335 } else { 9336 c.adderror(err) 9337 } 9338} 9339 9340// PADDSB: Add Packed Signed Byte Integers with Signed Saturation. 9341// 9342// Forms: 9343// 9344// PADDSB xmm xmm 9345// PADDSB m128 xmm 9346// Construct and append a PADDSB instruction to the active function. 9347// Operates on the global context. 9348func PADDSB(mx, x operand.Op) { ctx.PADDSB(mx, x) } 9349 9350// PADDSW: Add Packed Signed Word Integers with Signed Saturation. 9351// 9352// Forms: 9353// 9354// PADDSW xmm xmm 9355// PADDSW m128 xmm 9356// Construct and append a PADDSW instruction to the active function. 9357func (c *Context) PADDSW(mx, x operand.Op) { 9358 if inst, err := x86.PADDSW(mx, x); err == nil { 9359 c.Instruction(inst) 9360 } else { 9361 c.adderror(err) 9362 } 9363} 9364 9365// PADDSW: Add Packed Signed Word Integers with Signed Saturation. 9366// 9367// Forms: 9368// 9369// PADDSW xmm xmm 9370// PADDSW m128 xmm 9371// Construct and append a PADDSW instruction to the active function. 9372// Operates on the global context. 9373func PADDSW(mx, x operand.Op) { ctx.PADDSW(mx, x) } 9374 9375// PADDUSB: Add Packed Unsigned Byte Integers with Unsigned Saturation. 9376// 9377// Forms: 9378// 9379// PADDUSB xmm xmm 9380// PADDUSB m128 xmm 9381// Construct and append a PADDUSB instruction to the active function. 9382func (c *Context) PADDUSB(mx, x operand.Op) { 9383 if inst, err := x86.PADDUSB(mx, x); err == nil { 9384 c.Instruction(inst) 9385 } else { 9386 c.adderror(err) 9387 } 9388} 9389 9390// PADDUSB: Add Packed Unsigned Byte Integers with Unsigned Saturation. 9391// 9392// Forms: 9393// 9394// PADDUSB xmm xmm 9395// PADDUSB m128 xmm 9396// Construct and append a PADDUSB instruction to the active function. 9397// Operates on the global context. 9398func PADDUSB(mx, x operand.Op) { ctx.PADDUSB(mx, x) } 9399 9400// PADDUSW: Add Packed Unsigned Word Integers with Unsigned Saturation. 9401// 9402// Forms: 9403// 9404// PADDUSW xmm xmm 9405// PADDUSW m128 xmm 9406// Construct and append a PADDUSW instruction to the active function. 9407func (c *Context) PADDUSW(mx, x operand.Op) { 9408 if inst, err := x86.PADDUSW(mx, x); err == nil { 9409 c.Instruction(inst) 9410 } else { 9411 c.adderror(err) 9412 } 9413} 9414 9415// PADDUSW: Add Packed Unsigned Word Integers with Unsigned Saturation. 9416// 9417// Forms: 9418// 9419// PADDUSW xmm xmm 9420// PADDUSW m128 xmm 9421// Construct and append a PADDUSW instruction to the active function. 9422// Operates on the global context. 9423func PADDUSW(mx, x operand.Op) { ctx.PADDUSW(mx, x) } 9424 9425// PADDW: Add Packed Word Integers. 9426// 9427// Forms: 9428// 9429// PADDW xmm xmm 9430// PADDW m128 xmm 9431// Construct and append a PADDW instruction to the active function. 9432func (c *Context) PADDW(mx, x operand.Op) { 9433 if inst, err := x86.PADDW(mx, x); err == nil { 9434 c.Instruction(inst) 9435 } else { 9436 c.adderror(err) 9437 } 9438} 9439 9440// PADDW: Add Packed Word Integers. 9441// 9442// Forms: 9443// 9444// PADDW xmm xmm 9445// PADDW m128 xmm 9446// Construct and append a PADDW instruction to the active function. 9447// Operates on the global context. 9448func PADDW(mx, x operand.Op) { ctx.PADDW(mx, x) } 9449 9450// PALIGNR: Packed Align Right. 9451// 9452// Forms: 9453// 9454// PALIGNR imm8 xmm xmm 9455// PALIGNR imm8 m128 xmm 9456// Construct and append a PALIGNR instruction to the active function. 9457func (c *Context) PALIGNR(i, mx, x operand.Op) { 9458 if inst, err := x86.PALIGNR(i, mx, x); err == nil { 9459 c.Instruction(inst) 9460 } else { 9461 c.adderror(err) 9462 } 9463} 9464 9465// PALIGNR: Packed Align Right. 9466// 9467// Forms: 9468// 9469// PALIGNR imm8 xmm xmm 9470// PALIGNR imm8 m128 xmm 9471// Construct and append a PALIGNR instruction to the active function. 9472// Operates on the global context. 9473func PALIGNR(i, mx, x operand.Op) { ctx.PALIGNR(i, mx, x) } 9474 9475// PAND: Packed Bitwise Logical AND. 9476// 9477// Forms: 9478// 9479// PAND xmm xmm 9480// PAND m128 xmm 9481// Construct and append a PAND instruction to the active function. 9482func (c *Context) PAND(mx, x operand.Op) { 9483 if inst, err := x86.PAND(mx, x); err == nil { 9484 c.Instruction(inst) 9485 } else { 9486 c.adderror(err) 9487 } 9488} 9489 9490// PAND: Packed Bitwise Logical AND. 9491// 9492// Forms: 9493// 9494// PAND xmm xmm 9495// PAND m128 xmm 9496// Construct and append a PAND instruction to the active function. 9497// Operates on the global context. 9498func PAND(mx, x operand.Op) { ctx.PAND(mx, x) } 9499 9500// PANDN: Packed Bitwise Logical AND NOT. 9501// 9502// Forms: 9503// 9504// PANDN xmm xmm 9505// PANDN m128 xmm 9506// Construct and append a PANDN instruction to the active function. 9507func (c *Context) PANDN(mx, x operand.Op) { 9508 if inst, err := x86.PANDN(mx, x); err == nil { 9509 c.Instruction(inst) 9510 } else { 9511 c.adderror(err) 9512 } 9513} 9514 9515// PANDN: Packed Bitwise Logical AND NOT. 9516// 9517// Forms: 9518// 9519// PANDN xmm xmm 9520// PANDN m128 xmm 9521// Construct and append a PANDN instruction to the active function. 9522// Operates on the global context. 9523func PANDN(mx, x operand.Op) { ctx.PANDN(mx, x) } 9524 9525// PAUSE: Spin Loop Hint. 9526// 9527// Forms: 9528// 9529// PAUSE 9530// Construct and append a PAUSE instruction to the active function. 9531func (c *Context) PAUSE() { 9532 if inst, err := x86.PAUSE(); err == nil { 9533 c.Instruction(inst) 9534 } else { 9535 c.adderror(err) 9536 } 9537} 9538 9539// PAUSE: Spin Loop Hint. 9540// 9541// Forms: 9542// 9543// PAUSE 9544// Construct and append a PAUSE instruction to the active function. 9545// Operates on the global context. 9546func PAUSE() { ctx.PAUSE() } 9547 9548// PAVGB: Average Packed Byte Integers. 9549// 9550// Forms: 9551// 9552// PAVGB xmm xmm 9553// PAVGB m128 xmm 9554// Construct and append a PAVGB instruction to the active function. 9555func (c *Context) PAVGB(mx, x operand.Op) { 9556 if inst, err := x86.PAVGB(mx, x); err == nil { 9557 c.Instruction(inst) 9558 } else { 9559 c.adderror(err) 9560 } 9561} 9562 9563// PAVGB: Average Packed Byte Integers. 9564// 9565// Forms: 9566// 9567// PAVGB xmm xmm 9568// PAVGB m128 xmm 9569// Construct and append a PAVGB instruction to the active function. 9570// Operates on the global context. 9571func PAVGB(mx, x operand.Op) { ctx.PAVGB(mx, x) } 9572 9573// PAVGW: Average Packed Word Integers. 9574// 9575// Forms: 9576// 9577// PAVGW xmm xmm 9578// PAVGW m128 xmm 9579// Construct and append a PAVGW instruction to the active function. 9580func (c *Context) PAVGW(mx, x operand.Op) { 9581 if inst, err := x86.PAVGW(mx, x); err == nil { 9582 c.Instruction(inst) 9583 } else { 9584 c.adderror(err) 9585 } 9586} 9587 9588// PAVGW: Average Packed Word Integers. 9589// 9590// Forms: 9591// 9592// PAVGW xmm xmm 9593// PAVGW m128 xmm 9594// Construct and append a PAVGW instruction to the active function. 9595// Operates on the global context. 9596func PAVGW(mx, x operand.Op) { ctx.PAVGW(mx, x) } 9597 9598// PBLENDVB: Variable Blend Packed Bytes. 9599// 9600// Forms: 9601// 9602// PBLENDVB xmm0 xmm xmm 9603// PBLENDVB xmm0 m128 xmm 9604// Construct and append a PBLENDVB instruction to the active function. 9605func (c *Context) PBLENDVB(x, mx, x1 operand.Op) { 9606 if inst, err := x86.PBLENDVB(x, mx, x1); err == nil { 9607 c.Instruction(inst) 9608 } else { 9609 c.adderror(err) 9610 } 9611} 9612 9613// PBLENDVB: Variable Blend Packed Bytes. 9614// 9615// Forms: 9616// 9617// PBLENDVB xmm0 xmm xmm 9618// PBLENDVB xmm0 m128 xmm 9619// Construct and append a PBLENDVB instruction to the active function. 9620// Operates on the global context. 9621func PBLENDVB(x, mx, x1 operand.Op) { ctx.PBLENDVB(x, mx, x1) } 9622 9623// PBLENDW: Blend Packed Words. 9624// 9625// Forms: 9626// 9627// PBLENDW imm8 xmm xmm 9628// PBLENDW imm8 m128 xmm 9629// Construct and append a PBLENDW instruction to the active function. 9630func (c *Context) PBLENDW(i, mx, x operand.Op) { 9631 if inst, err := x86.PBLENDW(i, mx, x); err == nil { 9632 c.Instruction(inst) 9633 } else { 9634 c.adderror(err) 9635 } 9636} 9637 9638// PBLENDW: Blend Packed Words. 9639// 9640// Forms: 9641// 9642// PBLENDW imm8 xmm xmm 9643// PBLENDW imm8 m128 xmm 9644// Construct and append a PBLENDW instruction to the active function. 9645// Operates on the global context. 9646func PBLENDW(i, mx, x operand.Op) { ctx.PBLENDW(i, mx, x) } 9647 9648// PCLMULQDQ: Carry-Less Quadword Multiplication. 9649// 9650// Forms: 9651// 9652// PCLMULQDQ imm8 xmm xmm 9653// PCLMULQDQ imm8 m128 xmm 9654// Construct and append a PCLMULQDQ instruction to the active function. 9655func (c *Context) PCLMULQDQ(i, mx, x operand.Op) { 9656 if inst, err := x86.PCLMULQDQ(i, mx, x); err == nil { 9657 c.Instruction(inst) 9658 } else { 9659 c.adderror(err) 9660 } 9661} 9662 9663// PCLMULQDQ: Carry-Less Quadword Multiplication. 9664// 9665// Forms: 9666// 9667// PCLMULQDQ imm8 xmm xmm 9668// PCLMULQDQ imm8 m128 xmm 9669// Construct and append a PCLMULQDQ instruction to the active function. 9670// Operates on the global context. 9671func PCLMULQDQ(i, mx, x operand.Op) { ctx.PCLMULQDQ(i, mx, x) } 9672 9673// PCMPEQB: Compare Packed Byte Data for Equality. 9674// 9675// Forms: 9676// 9677// PCMPEQB xmm xmm 9678// PCMPEQB m128 xmm 9679// Construct and append a PCMPEQB instruction to the active function. 9680func (c *Context) PCMPEQB(mx, x operand.Op) { 9681 if inst, err := x86.PCMPEQB(mx, x); err == nil { 9682 c.Instruction(inst) 9683 } else { 9684 c.adderror(err) 9685 } 9686} 9687 9688// PCMPEQB: Compare Packed Byte Data for Equality. 9689// 9690// Forms: 9691// 9692// PCMPEQB xmm xmm 9693// PCMPEQB m128 xmm 9694// Construct and append a PCMPEQB instruction to the active function. 9695// Operates on the global context. 9696func PCMPEQB(mx, x operand.Op) { ctx.PCMPEQB(mx, x) } 9697 9698// PCMPEQL: Compare Packed Doubleword Data for Equality. 9699// 9700// Forms: 9701// 9702// PCMPEQL xmm xmm 9703// PCMPEQL m128 xmm 9704// Construct and append a PCMPEQL instruction to the active function. 9705func (c *Context) PCMPEQL(mx, x operand.Op) { 9706 if inst, err := x86.PCMPEQL(mx, x); err == nil { 9707 c.Instruction(inst) 9708 } else { 9709 c.adderror(err) 9710 } 9711} 9712 9713// PCMPEQL: Compare Packed Doubleword Data for Equality. 9714// 9715// Forms: 9716// 9717// PCMPEQL xmm xmm 9718// PCMPEQL m128 xmm 9719// Construct and append a PCMPEQL instruction to the active function. 9720// Operates on the global context. 9721func PCMPEQL(mx, x operand.Op) { ctx.PCMPEQL(mx, x) } 9722 9723// PCMPEQQ: Compare Packed Quadword Data for Equality. 9724// 9725// Forms: 9726// 9727// PCMPEQQ xmm xmm 9728// PCMPEQQ m128 xmm 9729// Construct and append a PCMPEQQ instruction to the active function. 9730func (c *Context) PCMPEQQ(mx, x operand.Op) { 9731 if inst, err := x86.PCMPEQQ(mx, x); err == nil { 9732 c.Instruction(inst) 9733 } else { 9734 c.adderror(err) 9735 } 9736} 9737 9738// PCMPEQQ: Compare Packed Quadword Data for Equality. 9739// 9740// Forms: 9741// 9742// PCMPEQQ xmm xmm 9743// PCMPEQQ m128 xmm 9744// Construct and append a PCMPEQQ instruction to the active function. 9745// Operates on the global context. 9746func PCMPEQQ(mx, x operand.Op) { ctx.PCMPEQQ(mx, x) } 9747 9748// PCMPEQW: Compare Packed Word Data for Equality. 9749// 9750// Forms: 9751// 9752// PCMPEQW xmm xmm 9753// PCMPEQW m128 xmm 9754// Construct and append a PCMPEQW instruction to the active function. 9755func (c *Context) PCMPEQW(mx, x operand.Op) { 9756 if inst, err := x86.PCMPEQW(mx, x); err == nil { 9757 c.Instruction(inst) 9758 } else { 9759 c.adderror(err) 9760 } 9761} 9762 9763// PCMPEQW: Compare Packed Word Data for Equality. 9764// 9765// Forms: 9766// 9767// PCMPEQW xmm xmm 9768// PCMPEQW m128 xmm 9769// Construct and append a PCMPEQW instruction to the active function. 9770// Operates on the global context. 9771func PCMPEQW(mx, x operand.Op) { ctx.PCMPEQW(mx, x) } 9772 9773// PCMPESTRI: Packed Compare Explicit Length Strings, Return Index. 9774// 9775// Forms: 9776// 9777// PCMPESTRI imm8 xmm xmm 9778// PCMPESTRI imm8 m128 xmm 9779// Construct and append a PCMPESTRI instruction to the active function. 9780func (c *Context) PCMPESTRI(i, mx, x operand.Op) { 9781 if inst, err := x86.PCMPESTRI(i, mx, x); err == nil { 9782 c.Instruction(inst) 9783 } else { 9784 c.adderror(err) 9785 } 9786} 9787 9788// PCMPESTRI: Packed Compare Explicit Length Strings, Return Index. 9789// 9790// Forms: 9791// 9792// PCMPESTRI imm8 xmm xmm 9793// PCMPESTRI imm8 m128 xmm 9794// Construct and append a PCMPESTRI instruction to the active function. 9795// Operates on the global context. 9796func PCMPESTRI(i, mx, x operand.Op) { ctx.PCMPESTRI(i, mx, x) } 9797 9798// PCMPESTRM: Packed Compare Explicit Length Strings, Return Mask. 9799// 9800// Forms: 9801// 9802// PCMPESTRM imm8 xmm xmm 9803// PCMPESTRM imm8 m128 xmm 9804// Construct and append a PCMPESTRM instruction to the active function. 9805func (c *Context) PCMPESTRM(i, mx, x operand.Op) { 9806 if inst, err := x86.PCMPESTRM(i, mx, x); err == nil { 9807 c.Instruction(inst) 9808 } else { 9809 c.adderror(err) 9810 } 9811} 9812 9813// PCMPESTRM: Packed Compare Explicit Length Strings, Return Mask. 9814// 9815// Forms: 9816// 9817// PCMPESTRM imm8 xmm xmm 9818// PCMPESTRM imm8 m128 xmm 9819// Construct and append a PCMPESTRM instruction to the active function. 9820// Operates on the global context. 9821func PCMPESTRM(i, mx, x operand.Op) { ctx.PCMPESTRM(i, mx, x) } 9822 9823// PCMPGTB: Compare Packed Signed Byte Integers for Greater Than. 9824// 9825// Forms: 9826// 9827// PCMPGTB xmm xmm 9828// PCMPGTB m128 xmm 9829// Construct and append a PCMPGTB instruction to the active function. 9830func (c *Context) PCMPGTB(mx, x operand.Op) { 9831 if inst, err := x86.PCMPGTB(mx, x); err == nil { 9832 c.Instruction(inst) 9833 } else { 9834 c.adderror(err) 9835 } 9836} 9837 9838// PCMPGTB: Compare Packed Signed Byte Integers for Greater Than. 9839// 9840// Forms: 9841// 9842// PCMPGTB xmm xmm 9843// PCMPGTB m128 xmm 9844// Construct and append a PCMPGTB instruction to the active function. 9845// Operates on the global context. 9846func PCMPGTB(mx, x operand.Op) { ctx.PCMPGTB(mx, x) } 9847 9848// PCMPGTL: Compare Packed Signed Doubleword Integers for Greater Than. 9849// 9850// Forms: 9851// 9852// PCMPGTL xmm xmm 9853// PCMPGTL m128 xmm 9854// Construct and append a PCMPGTL instruction to the active function. 9855func (c *Context) PCMPGTL(mx, x operand.Op) { 9856 if inst, err := x86.PCMPGTL(mx, x); err == nil { 9857 c.Instruction(inst) 9858 } else { 9859 c.adderror(err) 9860 } 9861} 9862 9863// PCMPGTL: Compare Packed Signed Doubleword Integers for Greater Than. 9864// 9865// Forms: 9866// 9867// PCMPGTL xmm xmm 9868// PCMPGTL m128 xmm 9869// Construct and append a PCMPGTL instruction to the active function. 9870// Operates on the global context. 9871func PCMPGTL(mx, x operand.Op) { ctx.PCMPGTL(mx, x) } 9872 9873// PCMPGTQ: Compare Packed Data for Greater Than. 9874// 9875// Forms: 9876// 9877// PCMPGTQ xmm xmm 9878// PCMPGTQ m128 xmm 9879// Construct and append a PCMPGTQ instruction to the active function. 9880func (c *Context) PCMPGTQ(mx, x operand.Op) { 9881 if inst, err := x86.PCMPGTQ(mx, x); err == nil { 9882 c.Instruction(inst) 9883 } else { 9884 c.adderror(err) 9885 } 9886} 9887 9888// PCMPGTQ: Compare Packed Data for Greater Than. 9889// 9890// Forms: 9891// 9892// PCMPGTQ xmm xmm 9893// PCMPGTQ m128 xmm 9894// Construct and append a PCMPGTQ instruction to the active function. 9895// Operates on the global context. 9896func PCMPGTQ(mx, x operand.Op) { ctx.PCMPGTQ(mx, x) } 9897 9898// PCMPGTW: Compare Packed Signed Word Integers for Greater Than. 9899// 9900// Forms: 9901// 9902// PCMPGTW xmm xmm 9903// PCMPGTW m128 xmm 9904// Construct and append a PCMPGTW instruction to the active function. 9905func (c *Context) PCMPGTW(mx, x operand.Op) { 9906 if inst, err := x86.PCMPGTW(mx, x); err == nil { 9907 c.Instruction(inst) 9908 } else { 9909 c.adderror(err) 9910 } 9911} 9912 9913// PCMPGTW: Compare Packed Signed Word Integers for Greater Than. 9914// 9915// Forms: 9916// 9917// PCMPGTW xmm xmm 9918// PCMPGTW m128 xmm 9919// Construct and append a PCMPGTW instruction to the active function. 9920// Operates on the global context. 9921func PCMPGTW(mx, x operand.Op) { ctx.PCMPGTW(mx, x) } 9922 9923// PCMPISTRI: Packed Compare Implicit Length Strings, Return Index. 9924// 9925// Forms: 9926// 9927// PCMPISTRI imm8 xmm xmm 9928// PCMPISTRI imm8 m128 xmm 9929// Construct and append a PCMPISTRI instruction to the active function. 9930func (c *Context) PCMPISTRI(i, mx, x operand.Op) { 9931 if inst, err := x86.PCMPISTRI(i, mx, x); err == nil { 9932 c.Instruction(inst) 9933 } else { 9934 c.adderror(err) 9935 } 9936} 9937 9938// PCMPISTRI: Packed Compare Implicit Length Strings, Return Index. 9939// 9940// Forms: 9941// 9942// PCMPISTRI imm8 xmm xmm 9943// PCMPISTRI imm8 m128 xmm 9944// Construct and append a PCMPISTRI instruction to the active function. 9945// Operates on the global context. 9946func PCMPISTRI(i, mx, x operand.Op) { ctx.PCMPISTRI(i, mx, x) } 9947 9948// PCMPISTRM: Packed Compare Implicit Length Strings, Return Mask. 9949// 9950// Forms: 9951// 9952// PCMPISTRM imm8 xmm xmm 9953// PCMPISTRM imm8 m128 xmm 9954// Construct and append a PCMPISTRM instruction to the active function. 9955func (c *Context) PCMPISTRM(i, mx, x operand.Op) { 9956 if inst, err := x86.PCMPISTRM(i, mx, x); err == nil { 9957 c.Instruction(inst) 9958 } else { 9959 c.adderror(err) 9960 } 9961} 9962 9963// PCMPISTRM: Packed Compare Implicit Length Strings, Return Mask. 9964// 9965// Forms: 9966// 9967// PCMPISTRM imm8 xmm xmm 9968// PCMPISTRM imm8 m128 xmm 9969// Construct and append a PCMPISTRM instruction to the active function. 9970// Operates on the global context. 9971func PCMPISTRM(i, mx, x operand.Op) { ctx.PCMPISTRM(i, mx, x) } 9972 9973// PDEPL: Parallel Bits Deposit. 9974// 9975// Forms: 9976// 9977// PDEPL r32 r32 r32 9978// PDEPL m32 r32 r32 9979// Construct and append a PDEPL instruction to the active function. 9980func (c *Context) PDEPL(mr, r, r1 operand.Op) { 9981 if inst, err := x86.PDEPL(mr, r, r1); err == nil { 9982 c.Instruction(inst) 9983 } else { 9984 c.adderror(err) 9985 } 9986} 9987 9988// PDEPL: Parallel Bits Deposit. 9989// 9990// Forms: 9991// 9992// PDEPL r32 r32 r32 9993// PDEPL m32 r32 r32 9994// Construct and append a PDEPL instruction to the active function. 9995// Operates on the global context. 9996func PDEPL(mr, r, r1 operand.Op) { ctx.PDEPL(mr, r, r1) } 9997 9998// PDEPQ: Parallel Bits Deposit. 9999// 10000// Forms: 10001// 10002// PDEPQ r64 r64 r64 10003// PDEPQ m64 r64 r64 10004// Construct and append a PDEPQ instruction to the active function. 10005func (c *Context) PDEPQ(mr, r, r1 operand.Op) { 10006 if inst, err := x86.PDEPQ(mr, r, r1); err == nil { 10007 c.Instruction(inst) 10008 } else { 10009 c.adderror(err) 10010 } 10011} 10012 10013// PDEPQ: Parallel Bits Deposit. 10014// 10015// Forms: 10016// 10017// PDEPQ r64 r64 r64 10018// PDEPQ m64 r64 r64 10019// Construct and append a PDEPQ instruction to the active function. 10020// Operates on the global context. 10021func PDEPQ(mr, r, r1 operand.Op) { ctx.PDEPQ(mr, r, r1) } 10022 10023// PEXTL: Parallel Bits Extract. 10024// 10025// Forms: 10026// 10027// PEXTL r32 r32 r32 10028// PEXTL m32 r32 r32 10029// Construct and append a PEXTL instruction to the active function. 10030func (c *Context) PEXTL(mr, r, r1 operand.Op) { 10031 if inst, err := x86.PEXTL(mr, r, r1); err == nil { 10032 c.Instruction(inst) 10033 } else { 10034 c.adderror(err) 10035 } 10036} 10037 10038// PEXTL: Parallel Bits Extract. 10039// 10040// Forms: 10041// 10042// PEXTL r32 r32 r32 10043// PEXTL m32 r32 r32 10044// Construct and append a PEXTL instruction to the active function. 10045// Operates on the global context. 10046func PEXTL(mr, r, r1 operand.Op) { ctx.PEXTL(mr, r, r1) } 10047 10048// PEXTQ: Parallel Bits Extract. 10049// 10050// Forms: 10051// 10052// PEXTQ r64 r64 r64 10053// PEXTQ m64 r64 r64 10054// Construct and append a PEXTQ instruction to the active function. 10055func (c *Context) PEXTQ(mr, r, r1 operand.Op) { 10056 if inst, err := x86.PEXTQ(mr, r, r1); err == nil { 10057 c.Instruction(inst) 10058 } else { 10059 c.adderror(err) 10060 } 10061} 10062 10063// PEXTQ: Parallel Bits Extract. 10064// 10065// Forms: 10066// 10067// PEXTQ r64 r64 r64 10068// PEXTQ m64 r64 r64 10069// Construct and append a PEXTQ instruction to the active function. 10070// Operates on the global context. 10071func PEXTQ(mr, r, r1 operand.Op) { ctx.PEXTQ(mr, r, r1) } 10072 10073// PEXTRB: Extract Byte. 10074// 10075// Forms: 10076// 10077// PEXTRB imm8 xmm r32 10078// PEXTRB imm8 xmm m8 10079// Construct and append a PEXTRB instruction to the active function. 10080func (c *Context) PEXTRB(i, x, mr operand.Op) { 10081 if inst, err := x86.PEXTRB(i, x, mr); err == nil { 10082 c.Instruction(inst) 10083 } else { 10084 c.adderror(err) 10085 } 10086} 10087 10088// PEXTRB: Extract Byte. 10089// 10090// Forms: 10091// 10092// PEXTRB imm8 xmm r32 10093// PEXTRB imm8 xmm m8 10094// Construct and append a PEXTRB instruction to the active function. 10095// Operates on the global context. 10096func PEXTRB(i, x, mr operand.Op) { ctx.PEXTRB(i, x, mr) } 10097 10098// PEXTRD: Extract Doubleword. 10099// 10100// Forms: 10101// 10102// PEXTRD imm8 xmm r32 10103// PEXTRD imm8 xmm m32 10104// Construct and append a PEXTRD instruction to the active function. 10105func (c *Context) PEXTRD(i, x, mr operand.Op) { 10106 if inst, err := x86.PEXTRD(i, x, mr); err == nil { 10107 c.Instruction(inst) 10108 } else { 10109 c.adderror(err) 10110 } 10111} 10112 10113// PEXTRD: Extract Doubleword. 10114// 10115// Forms: 10116// 10117// PEXTRD imm8 xmm r32 10118// PEXTRD imm8 xmm m32 10119// Construct and append a PEXTRD instruction to the active function. 10120// Operates on the global context. 10121func PEXTRD(i, x, mr operand.Op) { ctx.PEXTRD(i, x, mr) } 10122 10123// PEXTRQ: Extract Quadword. 10124// 10125// Forms: 10126// 10127// PEXTRQ imm8 xmm r64 10128// PEXTRQ imm8 xmm m64 10129// Construct and append a PEXTRQ instruction to the active function. 10130func (c *Context) PEXTRQ(i, x, mr operand.Op) { 10131 if inst, err := x86.PEXTRQ(i, x, mr); err == nil { 10132 c.Instruction(inst) 10133 } else { 10134 c.adderror(err) 10135 } 10136} 10137 10138// PEXTRQ: Extract Quadword. 10139// 10140// Forms: 10141// 10142// PEXTRQ imm8 xmm r64 10143// PEXTRQ imm8 xmm m64 10144// Construct and append a PEXTRQ instruction to the active function. 10145// Operates on the global context. 10146func PEXTRQ(i, x, mr operand.Op) { ctx.PEXTRQ(i, x, mr) } 10147 10148// PEXTRW: Extract Word. 10149// 10150// Forms: 10151// 10152// PEXTRW imm8 xmm r32 10153// PEXTRW imm8 xmm m16 10154// Construct and append a PEXTRW instruction to the active function. 10155func (c *Context) PEXTRW(i, x, mr operand.Op) { 10156 if inst, err := x86.PEXTRW(i, x, mr); err == nil { 10157 c.Instruction(inst) 10158 } else { 10159 c.adderror(err) 10160 } 10161} 10162 10163// PEXTRW: Extract Word. 10164// 10165// Forms: 10166// 10167// PEXTRW imm8 xmm r32 10168// PEXTRW imm8 xmm m16 10169// Construct and append a PEXTRW instruction to the active function. 10170// Operates on the global context. 10171func PEXTRW(i, x, mr operand.Op) { ctx.PEXTRW(i, x, mr) } 10172 10173// PHADDD: Packed Horizontal Add Doubleword Integer. 10174// 10175// Forms: 10176// 10177// PHADDD xmm xmm 10178// PHADDD m128 xmm 10179// Construct and append a PHADDD instruction to the active function. 10180func (c *Context) PHADDD(mx, x operand.Op) { 10181 if inst, err := x86.PHADDD(mx, x); err == nil { 10182 c.Instruction(inst) 10183 } else { 10184 c.adderror(err) 10185 } 10186} 10187 10188// PHADDD: Packed Horizontal Add Doubleword Integer. 10189// 10190// Forms: 10191// 10192// PHADDD xmm xmm 10193// PHADDD m128 xmm 10194// Construct and append a PHADDD instruction to the active function. 10195// Operates on the global context. 10196func PHADDD(mx, x operand.Op) { ctx.PHADDD(mx, x) } 10197 10198// PHADDSW: Packed Horizontal Add Signed Word Integers with Signed Saturation. 10199// 10200// Forms: 10201// 10202// PHADDSW xmm xmm 10203// PHADDSW m128 xmm 10204// Construct and append a PHADDSW instruction to the active function. 10205func (c *Context) PHADDSW(mx, x operand.Op) { 10206 if inst, err := x86.PHADDSW(mx, x); err == nil { 10207 c.Instruction(inst) 10208 } else { 10209 c.adderror(err) 10210 } 10211} 10212 10213// PHADDSW: Packed Horizontal Add Signed Word Integers with Signed Saturation. 10214// 10215// Forms: 10216// 10217// PHADDSW xmm xmm 10218// PHADDSW m128 xmm 10219// Construct and append a PHADDSW instruction to the active function. 10220// Operates on the global context. 10221func PHADDSW(mx, x operand.Op) { ctx.PHADDSW(mx, x) } 10222 10223// PHADDW: Packed Horizontal Add Word Integers. 10224// 10225// Forms: 10226// 10227// PHADDW xmm xmm 10228// PHADDW m128 xmm 10229// Construct and append a PHADDW instruction to the active function. 10230func (c *Context) PHADDW(mx, x operand.Op) { 10231 if inst, err := x86.PHADDW(mx, x); err == nil { 10232 c.Instruction(inst) 10233 } else { 10234 c.adderror(err) 10235 } 10236} 10237 10238// PHADDW: Packed Horizontal Add Word Integers. 10239// 10240// Forms: 10241// 10242// PHADDW xmm xmm 10243// PHADDW m128 xmm 10244// Construct and append a PHADDW instruction to the active function. 10245// Operates on the global context. 10246func PHADDW(mx, x operand.Op) { ctx.PHADDW(mx, x) } 10247 10248// PHMINPOSUW: Packed Horizontal Minimum of Unsigned Word Integers. 10249// 10250// Forms: 10251// 10252// PHMINPOSUW xmm xmm 10253// PHMINPOSUW m128 xmm 10254// Construct and append a PHMINPOSUW instruction to the active function. 10255func (c *Context) PHMINPOSUW(mx, x operand.Op) { 10256 if inst, err := x86.PHMINPOSUW(mx, x); err == nil { 10257 c.Instruction(inst) 10258 } else { 10259 c.adderror(err) 10260 } 10261} 10262 10263// PHMINPOSUW: Packed Horizontal Minimum of Unsigned Word Integers. 10264// 10265// Forms: 10266// 10267// PHMINPOSUW xmm xmm 10268// PHMINPOSUW m128 xmm 10269// Construct and append a PHMINPOSUW instruction to the active function. 10270// Operates on the global context. 10271func PHMINPOSUW(mx, x operand.Op) { ctx.PHMINPOSUW(mx, x) } 10272 10273// PHSUBD: Packed Horizontal Subtract Doubleword Integers. 10274// 10275// Forms: 10276// 10277// PHSUBD xmm xmm 10278// PHSUBD m128 xmm 10279// Construct and append a PHSUBD instruction to the active function. 10280func (c *Context) PHSUBD(mx, x operand.Op) { 10281 if inst, err := x86.PHSUBD(mx, x); err == nil { 10282 c.Instruction(inst) 10283 } else { 10284 c.adderror(err) 10285 } 10286} 10287 10288// PHSUBD: Packed Horizontal Subtract Doubleword Integers. 10289// 10290// Forms: 10291// 10292// PHSUBD xmm xmm 10293// PHSUBD m128 xmm 10294// Construct and append a PHSUBD instruction to the active function. 10295// Operates on the global context. 10296func PHSUBD(mx, x operand.Op) { ctx.PHSUBD(mx, x) } 10297 10298// PHSUBSW: Packed Horizontal Subtract Signed Word Integers with Signed Saturation. 10299// 10300// Forms: 10301// 10302// PHSUBSW xmm xmm 10303// PHSUBSW m128 xmm 10304// Construct and append a PHSUBSW instruction to the active function. 10305func (c *Context) PHSUBSW(mx, x operand.Op) { 10306 if inst, err := x86.PHSUBSW(mx, x); err == nil { 10307 c.Instruction(inst) 10308 } else { 10309 c.adderror(err) 10310 } 10311} 10312 10313// PHSUBSW: Packed Horizontal Subtract Signed Word Integers with Signed Saturation. 10314// 10315// Forms: 10316// 10317// PHSUBSW xmm xmm 10318// PHSUBSW m128 xmm 10319// Construct and append a PHSUBSW instruction to the active function. 10320// Operates on the global context. 10321func PHSUBSW(mx, x operand.Op) { ctx.PHSUBSW(mx, x) } 10322 10323// PHSUBW: Packed Horizontal Subtract Word Integers. 10324// 10325// Forms: 10326// 10327// PHSUBW xmm xmm 10328// PHSUBW m128 xmm 10329// Construct and append a PHSUBW instruction to the active function. 10330func (c *Context) PHSUBW(mx, x operand.Op) { 10331 if inst, err := x86.PHSUBW(mx, x); err == nil { 10332 c.Instruction(inst) 10333 } else { 10334 c.adderror(err) 10335 } 10336} 10337 10338// PHSUBW: Packed Horizontal Subtract Word Integers. 10339// 10340// Forms: 10341// 10342// PHSUBW xmm xmm 10343// PHSUBW m128 xmm 10344// Construct and append a PHSUBW instruction to the active function. 10345// Operates on the global context. 10346func PHSUBW(mx, x operand.Op) { ctx.PHSUBW(mx, x) } 10347 10348// PINSRB: Insert Byte. 10349// 10350// Forms: 10351// 10352// PINSRB imm8 r32 xmm 10353// PINSRB imm8 m8 xmm 10354// Construct and append a PINSRB instruction to the active function. 10355func (c *Context) PINSRB(i, mr, x operand.Op) { 10356 if inst, err := x86.PINSRB(i, mr, x); err == nil { 10357 c.Instruction(inst) 10358 } else { 10359 c.adderror(err) 10360 } 10361} 10362 10363// PINSRB: Insert Byte. 10364// 10365// Forms: 10366// 10367// PINSRB imm8 r32 xmm 10368// PINSRB imm8 m8 xmm 10369// Construct and append a PINSRB instruction to the active function. 10370// Operates on the global context. 10371func PINSRB(i, mr, x operand.Op) { ctx.PINSRB(i, mr, x) } 10372 10373// PINSRD: Insert Doubleword. 10374// 10375// Forms: 10376// 10377// PINSRD imm8 r32 xmm 10378// PINSRD imm8 m32 xmm 10379// Construct and append a PINSRD instruction to the active function. 10380func (c *Context) PINSRD(i, mr, x operand.Op) { 10381 if inst, err := x86.PINSRD(i, mr, x); err == nil { 10382 c.Instruction(inst) 10383 } else { 10384 c.adderror(err) 10385 } 10386} 10387 10388// PINSRD: Insert Doubleword. 10389// 10390// Forms: 10391// 10392// PINSRD imm8 r32 xmm 10393// PINSRD imm8 m32 xmm 10394// Construct and append a PINSRD instruction to the active function. 10395// Operates on the global context. 10396func PINSRD(i, mr, x operand.Op) { ctx.PINSRD(i, mr, x) } 10397 10398// PINSRQ: Insert Quadword. 10399// 10400// Forms: 10401// 10402// PINSRQ imm8 r64 xmm 10403// PINSRQ imm8 m64 xmm 10404// Construct and append a PINSRQ instruction to the active function. 10405func (c *Context) PINSRQ(i, mr, x operand.Op) { 10406 if inst, err := x86.PINSRQ(i, mr, x); err == nil { 10407 c.Instruction(inst) 10408 } else { 10409 c.adderror(err) 10410 } 10411} 10412 10413// PINSRQ: Insert Quadword. 10414// 10415// Forms: 10416// 10417// PINSRQ imm8 r64 xmm 10418// PINSRQ imm8 m64 xmm 10419// Construct and append a PINSRQ instruction to the active function. 10420// Operates on the global context. 10421func PINSRQ(i, mr, x operand.Op) { ctx.PINSRQ(i, mr, x) } 10422 10423// PINSRW: Insert Word. 10424// 10425// Forms: 10426// 10427// PINSRW imm8 r32 xmm 10428// PINSRW imm8 m16 xmm 10429// Construct and append a PINSRW instruction to the active function. 10430func (c *Context) PINSRW(i, mr, x operand.Op) { 10431 if inst, err := x86.PINSRW(i, mr, x); err == nil { 10432 c.Instruction(inst) 10433 } else { 10434 c.adderror(err) 10435 } 10436} 10437 10438// PINSRW: Insert Word. 10439// 10440// Forms: 10441// 10442// PINSRW imm8 r32 xmm 10443// PINSRW imm8 m16 xmm 10444// Construct and append a PINSRW instruction to the active function. 10445// Operates on the global context. 10446func PINSRW(i, mr, x operand.Op) { ctx.PINSRW(i, mr, x) } 10447 10448// PMADDUBSW: Multiply and Add Packed Signed and Unsigned Byte Integers. 10449// 10450// Forms: 10451// 10452// PMADDUBSW xmm xmm 10453// PMADDUBSW m128 xmm 10454// Construct and append a PMADDUBSW instruction to the active function. 10455func (c *Context) PMADDUBSW(mx, x operand.Op) { 10456 if inst, err := x86.PMADDUBSW(mx, x); err == nil { 10457 c.Instruction(inst) 10458 } else { 10459 c.adderror(err) 10460 } 10461} 10462 10463// PMADDUBSW: Multiply and Add Packed Signed and Unsigned Byte Integers. 10464// 10465// Forms: 10466// 10467// PMADDUBSW xmm xmm 10468// PMADDUBSW m128 xmm 10469// Construct and append a PMADDUBSW instruction to the active function. 10470// Operates on the global context. 10471func PMADDUBSW(mx, x operand.Op) { ctx.PMADDUBSW(mx, x) } 10472 10473// PMADDWL: Multiply and Add Packed Signed Word Integers. 10474// 10475// Forms: 10476// 10477// PMADDWL xmm xmm 10478// PMADDWL m128 xmm 10479// Construct and append a PMADDWL instruction to the active function. 10480func (c *Context) PMADDWL(mx, x operand.Op) { 10481 if inst, err := x86.PMADDWL(mx, x); err == nil { 10482 c.Instruction(inst) 10483 } else { 10484 c.adderror(err) 10485 } 10486} 10487 10488// PMADDWL: Multiply and Add Packed Signed Word Integers. 10489// 10490// Forms: 10491// 10492// PMADDWL xmm xmm 10493// PMADDWL m128 xmm 10494// Construct and append a PMADDWL instruction to the active function. 10495// Operates on the global context. 10496func PMADDWL(mx, x operand.Op) { ctx.PMADDWL(mx, x) } 10497 10498// PMAXSB: Maximum of Packed Signed Byte Integers. 10499// 10500// Forms: 10501// 10502// PMAXSB xmm xmm 10503// PMAXSB m128 xmm 10504// Construct and append a PMAXSB instruction to the active function. 10505func (c *Context) PMAXSB(mx, x operand.Op) { 10506 if inst, err := x86.PMAXSB(mx, x); err == nil { 10507 c.Instruction(inst) 10508 } else { 10509 c.adderror(err) 10510 } 10511} 10512 10513// PMAXSB: Maximum of Packed Signed Byte Integers. 10514// 10515// Forms: 10516// 10517// PMAXSB xmm xmm 10518// PMAXSB m128 xmm 10519// Construct and append a PMAXSB instruction to the active function. 10520// Operates on the global context. 10521func PMAXSB(mx, x operand.Op) { ctx.PMAXSB(mx, x) } 10522 10523// PMAXSD: Maximum of Packed Signed Doubleword Integers. 10524// 10525// Forms: 10526// 10527// PMAXSD xmm xmm 10528// PMAXSD m128 xmm 10529// Construct and append a PMAXSD instruction to the active function. 10530func (c *Context) PMAXSD(mx, x operand.Op) { 10531 if inst, err := x86.PMAXSD(mx, x); err == nil { 10532 c.Instruction(inst) 10533 } else { 10534 c.adderror(err) 10535 } 10536} 10537 10538// PMAXSD: Maximum of Packed Signed Doubleword Integers. 10539// 10540// Forms: 10541// 10542// PMAXSD xmm xmm 10543// PMAXSD m128 xmm 10544// Construct and append a PMAXSD instruction to the active function. 10545// Operates on the global context. 10546func PMAXSD(mx, x operand.Op) { ctx.PMAXSD(mx, x) } 10547 10548// PMAXSW: Maximum of Packed Signed Word Integers. 10549// 10550// Forms: 10551// 10552// PMAXSW xmm xmm 10553// PMAXSW m128 xmm 10554// Construct and append a PMAXSW instruction to the active function. 10555func (c *Context) PMAXSW(mx, x operand.Op) { 10556 if inst, err := x86.PMAXSW(mx, x); err == nil { 10557 c.Instruction(inst) 10558 } else { 10559 c.adderror(err) 10560 } 10561} 10562 10563// PMAXSW: Maximum of Packed Signed Word Integers. 10564// 10565// Forms: 10566// 10567// PMAXSW xmm xmm 10568// PMAXSW m128 xmm 10569// Construct and append a PMAXSW instruction to the active function. 10570// Operates on the global context. 10571func PMAXSW(mx, x operand.Op) { ctx.PMAXSW(mx, x) } 10572 10573// PMAXUB: Maximum of Packed Unsigned Byte Integers. 10574// 10575// Forms: 10576// 10577// PMAXUB xmm xmm 10578// PMAXUB m128 xmm 10579// Construct and append a PMAXUB instruction to the active function. 10580func (c *Context) PMAXUB(mx, x operand.Op) { 10581 if inst, err := x86.PMAXUB(mx, x); err == nil { 10582 c.Instruction(inst) 10583 } else { 10584 c.adderror(err) 10585 } 10586} 10587 10588// PMAXUB: Maximum of Packed Unsigned Byte Integers. 10589// 10590// Forms: 10591// 10592// PMAXUB xmm xmm 10593// PMAXUB m128 xmm 10594// Construct and append a PMAXUB instruction to the active function. 10595// Operates on the global context. 10596func PMAXUB(mx, x operand.Op) { ctx.PMAXUB(mx, x) } 10597 10598// PMAXUD: Maximum of Packed Unsigned Doubleword Integers. 10599// 10600// Forms: 10601// 10602// PMAXUD xmm xmm 10603// PMAXUD m128 xmm 10604// Construct and append a PMAXUD instruction to the active function. 10605func (c *Context) PMAXUD(mx, x operand.Op) { 10606 if inst, err := x86.PMAXUD(mx, x); err == nil { 10607 c.Instruction(inst) 10608 } else { 10609 c.adderror(err) 10610 } 10611} 10612 10613// PMAXUD: Maximum of Packed Unsigned Doubleword Integers. 10614// 10615// Forms: 10616// 10617// PMAXUD xmm xmm 10618// PMAXUD m128 xmm 10619// Construct and append a PMAXUD instruction to the active function. 10620// Operates on the global context. 10621func PMAXUD(mx, x operand.Op) { ctx.PMAXUD(mx, x) } 10622 10623// PMAXUW: Maximum of Packed Unsigned Word Integers. 10624// 10625// Forms: 10626// 10627// PMAXUW xmm xmm 10628// PMAXUW m128 xmm 10629// Construct and append a PMAXUW instruction to the active function. 10630func (c *Context) PMAXUW(mx, x operand.Op) { 10631 if inst, err := x86.PMAXUW(mx, x); err == nil { 10632 c.Instruction(inst) 10633 } else { 10634 c.adderror(err) 10635 } 10636} 10637 10638// PMAXUW: Maximum of Packed Unsigned Word Integers. 10639// 10640// Forms: 10641// 10642// PMAXUW xmm xmm 10643// PMAXUW m128 xmm 10644// Construct and append a PMAXUW instruction to the active function. 10645// Operates on the global context. 10646func PMAXUW(mx, x operand.Op) { ctx.PMAXUW(mx, x) } 10647 10648// PMINSB: Minimum of Packed Signed Byte Integers. 10649// 10650// Forms: 10651// 10652// PMINSB xmm xmm 10653// PMINSB m128 xmm 10654// Construct and append a PMINSB instruction to the active function. 10655func (c *Context) PMINSB(mx, x operand.Op) { 10656 if inst, err := x86.PMINSB(mx, x); err == nil { 10657 c.Instruction(inst) 10658 } else { 10659 c.adderror(err) 10660 } 10661} 10662 10663// PMINSB: Minimum of Packed Signed Byte Integers. 10664// 10665// Forms: 10666// 10667// PMINSB xmm xmm 10668// PMINSB m128 xmm 10669// Construct and append a PMINSB instruction to the active function. 10670// Operates on the global context. 10671func PMINSB(mx, x operand.Op) { ctx.PMINSB(mx, x) } 10672 10673// PMINSD: Minimum of Packed Signed Doubleword Integers. 10674// 10675// Forms: 10676// 10677// PMINSD xmm xmm 10678// PMINSD m128 xmm 10679// Construct and append a PMINSD instruction to the active function. 10680func (c *Context) PMINSD(mx, x operand.Op) { 10681 if inst, err := x86.PMINSD(mx, x); err == nil { 10682 c.Instruction(inst) 10683 } else { 10684 c.adderror(err) 10685 } 10686} 10687 10688// PMINSD: Minimum of Packed Signed Doubleword Integers. 10689// 10690// Forms: 10691// 10692// PMINSD xmm xmm 10693// PMINSD m128 xmm 10694// Construct and append a PMINSD instruction to the active function. 10695// Operates on the global context. 10696func PMINSD(mx, x operand.Op) { ctx.PMINSD(mx, x) } 10697 10698// PMINSW: Minimum of Packed Signed Word Integers. 10699// 10700// Forms: 10701// 10702// PMINSW xmm xmm 10703// PMINSW m128 xmm 10704// Construct and append a PMINSW instruction to the active function. 10705func (c *Context) PMINSW(mx, x operand.Op) { 10706 if inst, err := x86.PMINSW(mx, x); err == nil { 10707 c.Instruction(inst) 10708 } else { 10709 c.adderror(err) 10710 } 10711} 10712 10713// PMINSW: Minimum of Packed Signed Word Integers. 10714// 10715// Forms: 10716// 10717// PMINSW xmm xmm 10718// PMINSW m128 xmm 10719// Construct and append a PMINSW instruction to the active function. 10720// Operates on the global context. 10721func PMINSW(mx, x operand.Op) { ctx.PMINSW(mx, x) } 10722 10723// PMINUB: Minimum of Packed Unsigned Byte Integers. 10724// 10725// Forms: 10726// 10727// PMINUB xmm xmm 10728// PMINUB m128 xmm 10729// Construct and append a PMINUB instruction to the active function. 10730func (c *Context) PMINUB(mx, x operand.Op) { 10731 if inst, err := x86.PMINUB(mx, x); err == nil { 10732 c.Instruction(inst) 10733 } else { 10734 c.adderror(err) 10735 } 10736} 10737 10738// PMINUB: Minimum of Packed Unsigned Byte Integers. 10739// 10740// Forms: 10741// 10742// PMINUB xmm xmm 10743// PMINUB m128 xmm 10744// Construct and append a PMINUB instruction to the active function. 10745// Operates on the global context. 10746func PMINUB(mx, x operand.Op) { ctx.PMINUB(mx, x) } 10747 10748// PMINUD: Minimum of Packed Unsigned Doubleword Integers. 10749// 10750// Forms: 10751// 10752// PMINUD xmm xmm 10753// PMINUD m128 xmm 10754// Construct and append a PMINUD instruction to the active function. 10755func (c *Context) PMINUD(mx, x operand.Op) { 10756 if inst, err := x86.PMINUD(mx, x); err == nil { 10757 c.Instruction(inst) 10758 } else { 10759 c.adderror(err) 10760 } 10761} 10762 10763// PMINUD: Minimum of Packed Unsigned Doubleword Integers. 10764// 10765// Forms: 10766// 10767// PMINUD xmm xmm 10768// PMINUD m128 xmm 10769// Construct and append a PMINUD instruction to the active function. 10770// Operates on the global context. 10771func PMINUD(mx, x operand.Op) { ctx.PMINUD(mx, x) } 10772 10773// PMINUW: Minimum of Packed Unsigned Word Integers. 10774// 10775// Forms: 10776// 10777// PMINUW xmm xmm 10778// PMINUW m128 xmm 10779// Construct and append a PMINUW instruction to the active function. 10780func (c *Context) PMINUW(mx, x operand.Op) { 10781 if inst, err := x86.PMINUW(mx, x); err == nil { 10782 c.Instruction(inst) 10783 } else { 10784 c.adderror(err) 10785 } 10786} 10787 10788// PMINUW: Minimum of Packed Unsigned Word Integers. 10789// 10790// Forms: 10791// 10792// PMINUW xmm xmm 10793// PMINUW m128 xmm 10794// Construct and append a PMINUW instruction to the active function. 10795// Operates on the global context. 10796func PMINUW(mx, x operand.Op) { ctx.PMINUW(mx, x) } 10797 10798// PMOVMSKB: Move Byte Mask. 10799// 10800// Forms: 10801// 10802// PMOVMSKB xmm r32 10803// Construct and append a PMOVMSKB instruction to the active function. 10804func (c *Context) PMOVMSKB(x, r operand.Op) { 10805 if inst, err := x86.PMOVMSKB(x, r); err == nil { 10806 c.Instruction(inst) 10807 } else { 10808 c.adderror(err) 10809 } 10810} 10811 10812// PMOVMSKB: Move Byte Mask. 10813// 10814// Forms: 10815// 10816// PMOVMSKB xmm r32 10817// Construct and append a PMOVMSKB instruction to the active function. 10818// Operates on the global context. 10819func PMOVMSKB(x, r operand.Op) { ctx.PMOVMSKB(x, r) } 10820 10821// PMOVSXBD: Move Packed Byte Integers to Doubleword Integers with Sign Extension. 10822// 10823// Forms: 10824// 10825// PMOVSXBD xmm xmm 10826// PMOVSXBD m32 xmm 10827// Construct and append a PMOVSXBD instruction to the active function. 10828func (c *Context) PMOVSXBD(mx, x operand.Op) { 10829 if inst, err := x86.PMOVSXBD(mx, x); err == nil { 10830 c.Instruction(inst) 10831 } else { 10832 c.adderror(err) 10833 } 10834} 10835 10836// PMOVSXBD: Move Packed Byte Integers to Doubleword Integers with Sign Extension. 10837// 10838// Forms: 10839// 10840// PMOVSXBD xmm xmm 10841// PMOVSXBD m32 xmm 10842// Construct and append a PMOVSXBD instruction to the active function. 10843// Operates on the global context. 10844func PMOVSXBD(mx, x operand.Op) { ctx.PMOVSXBD(mx, x) } 10845 10846// PMOVSXBQ: Move Packed Byte Integers to Quadword Integers with Sign Extension. 10847// 10848// Forms: 10849// 10850// PMOVSXBQ xmm xmm 10851// PMOVSXBQ m16 xmm 10852// Construct and append a PMOVSXBQ instruction to the active function. 10853func (c *Context) PMOVSXBQ(mx, x operand.Op) { 10854 if inst, err := x86.PMOVSXBQ(mx, x); err == nil { 10855 c.Instruction(inst) 10856 } else { 10857 c.adderror(err) 10858 } 10859} 10860 10861// PMOVSXBQ: Move Packed Byte Integers to Quadword Integers with Sign Extension. 10862// 10863// Forms: 10864// 10865// PMOVSXBQ xmm xmm 10866// PMOVSXBQ m16 xmm 10867// Construct and append a PMOVSXBQ instruction to the active function. 10868// Operates on the global context. 10869func PMOVSXBQ(mx, x operand.Op) { ctx.PMOVSXBQ(mx, x) } 10870 10871// PMOVSXBW: Move Packed Byte Integers to Word Integers with Sign Extension. 10872// 10873// Forms: 10874// 10875// PMOVSXBW xmm xmm 10876// PMOVSXBW m64 xmm 10877// Construct and append a PMOVSXBW instruction to the active function. 10878func (c *Context) PMOVSXBW(mx, x operand.Op) { 10879 if inst, err := x86.PMOVSXBW(mx, x); err == nil { 10880 c.Instruction(inst) 10881 } else { 10882 c.adderror(err) 10883 } 10884} 10885 10886// PMOVSXBW: Move Packed Byte Integers to Word Integers with Sign Extension. 10887// 10888// Forms: 10889// 10890// PMOVSXBW xmm xmm 10891// PMOVSXBW m64 xmm 10892// Construct and append a PMOVSXBW instruction to the active function. 10893// Operates on the global context. 10894func PMOVSXBW(mx, x operand.Op) { ctx.PMOVSXBW(mx, x) } 10895 10896// PMOVSXDQ: Move Packed Doubleword Integers to Quadword Integers with Sign Extension. 10897// 10898// Forms: 10899// 10900// PMOVSXDQ xmm xmm 10901// PMOVSXDQ m64 xmm 10902// Construct and append a PMOVSXDQ instruction to the active function. 10903func (c *Context) PMOVSXDQ(mx, x operand.Op) { 10904 if inst, err := x86.PMOVSXDQ(mx, x); err == nil { 10905 c.Instruction(inst) 10906 } else { 10907 c.adderror(err) 10908 } 10909} 10910 10911// PMOVSXDQ: Move Packed Doubleword Integers to Quadword Integers with Sign Extension. 10912// 10913// Forms: 10914// 10915// PMOVSXDQ xmm xmm 10916// PMOVSXDQ m64 xmm 10917// Construct and append a PMOVSXDQ instruction to the active function. 10918// Operates on the global context. 10919func PMOVSXDQ(mx, x operand.Op) { ctx.PMOVSXDQ(mx, x) } 10920 10921// PMOVSXWD: Move Packed Word Integers to Doubleword Integers with Sign Extension. 10922// 10923// Forms: 10924// 10925// PMOVSXWD xmm xmm 10926// PMOVSXWD m64 xmm 10927// Construct and append a PMOVSXWD instruction to the active function. 10928func (c *Context) PMOVSXWD(mx, x operand.Op) { 10929 if inst, err := x86.PMOVSXWD(mx, x); err == nil { 10930 c.Instruction(inst) 10931 } else { 10932 c.adderror(err) 10933 } 10934} 10935 10936// PMOVSXWD: Move Packed Word Integers to Doubleword Integers with Sign Extension. 10937// 10938// Forms: 10939// 10940// PMOVSXWD xmm xmm 10941// PMOVSXWD m64 xmm 10942// Construct and append a PMOVSXWD instruction to the active function. 10943// Operates on the global context. 10944func PMOVSXWD(mx, x operand.Op) { ctx.PMOVSXWD(mx, x) } 10945 10946// PMOVSXWQ: Move Packed Word Integers to Quadword Integers with Sign Extension. 10947// 10948// Forms: 10949// 10950// PMOVSXWQ xmm xmm 10951// PMOVSXWQ m32 xmm 10952// Construct and append a PMOVSXWQ instruction to the active function. 10953func (c *Context) PMOVSXWQ(mx, x operand.Op) { 10954 if inst, err := x86.PMOVSXWQ(mx, x); err == nil { 10955 c.Instruction(inst) 10956 } else { 10957 c.adderror(err) 10958 } 10959} 10960 10961// PMOVSXWQ: Move Packed Word Integers to Quadword Integers with Sign Extension. 10962// 10963// Forms: 10964// 10965// PMOVSXWQ xmm xmm 10966// PMOVSXWQ m32 xmm 10967// Construct and append a PMOVSXWQ instruction to the active function. 10968// Operates on the global context. 10969func PMOVSXWQ(mx, x operand.Op) { ctx.PMOVSXWQ(mx, x) } 10970 10971// PMOVZXBD: Move Packed Byte Integers to Doubleword Integers with Zero Extension. 10972// 10973// Forms: 10974// 10975// PMOVZXBD xmm xmm 10976// PMOVZXBD m32 xmm 10977// Construct and append a PMOVZXBD instruction to the active function. 10978func (c *Context) PMOVZXBD(mx, x operand.Op) { 10979 if inst, err := x86.PMOVZXBD(mx, x); err == nil { 10980 c.Instruction(inst) 10981 } else { 10982 c.adderror(err) 10983 } 10984} 10985 10986// PMOVZXBD: Move Packed Byte Integers to Doubleword Integers with Zero Extension. 10987// 10988// Forms: 10989// 10990// PMOVZXBD xmm xmm 10991// PMOVZXBD m32 xmm 10992// Construct and append a PMOVZXBD instruction to the active function. 10993// Operates on the global context. 10994func PMOVZXBD(mx, x operand.Op) { ctx.PMOVZXBD(mx, x) } 10995 10996// PMOVZXBQ: Move Packed Byte Integers to Quadword Integers with Zero Extension. 10997// 10998// Forms: 10999// 11000// PMOVZXBQ xmm xmm 11001// PMOVZXBQ m16 xmm 11002// Construct and append a PMOVZXBQ instruction to the active function. 11003func (c *Context) PMOVZXBQ(mx, x operand.Op) { 11004 if inst, err := x86.PMOVZXBQ(mx, x); err == nil { 11005 c.Instruction(inst) 11006 } else { 11007 c.adderror(err) 11008 } 11009} 11010 11011// PMOVZXBQ: Move Packed Byte Integers to Quadword Integers with Zero Extension. 11012// 11013// Forms: 11014// 11015// PMOVZXBQ xmm xmm 11016// PMOVZXBQ m16 xmm 11017// Construct and append a PMOVZXBQ instruction to the active function. 11018// Operates on the global context. 11019func PMOVZXBQ(mx, x operand.Op) { ctx.PMOVZXBQ(mx, x) } 11020 11021// PMOVZXBW: Move Packed Byte Integers to Word Integers with Zero Extension. 11022// 11023// Forms: 11024// 11025// PMOVZXBW xmm xmm 11026// PMOVZXBW m64 xmm 11027// Construct and append a PMOVZXBW instruction to the active function. 11028func (c *Context) PMOVZXBW(mx, x operand.Op) { 11029 if inst, err := x86.PMOVZXBW(mx, x); err == nil { 11030 c.Instruction(inst) 11031 } else { 11032 c.adderror(err) 11033 } 11034} 11035 11036// PMOVZXBW: Move Packed Byte Integers to Word Integers with Zero Extension. 11037// 11038// Forms: 11039// 11040// PMOVZXBW xmm xmm 11041// PMOVZXBW m64 xmm 11042// Construct and append a PMOVZXBW instruction to the active function. 11043// Operates on the global context. 11044func PMOVZXBW(mx, x operand.Op) { ctx.PMOVZXBW(mx, x) } 11045 11046// PMOVZXDQ: Move Packed Doubleword Integers to Quadword Integers with Zero Extension. 11047// 11048// Forms: 11049// 11050// PMOVZXDQ xmm xmm 11051// PMOVZXDQ m64 xmm 11052// Construct and append a PMOVZXDQ instruction to the active function. 11053func (c *Context) PMOVZXDQ(mx, x operand.Op) { 11054 if inst, err := x86.PMOVZXDQ(mx, x); err == nil { 11055 c.Instruction(inst) 11056 } else { 11057 c.adderror(err) 11058 } 11059} 11060 11061// PMOVZXDQ: Move Packed Doubleword Integers to Quadword Integers with Zero Extension. 11062// 11063// Forms: 11064// 11065// PMOVZXDQ xmm xmm 11066// PMOVZXDQ m64 xmm 11067// Construct and append a PMOVZXDQ instruction to the active function. 11068// Operates on the global context. 11069func PMOVZXDQ(mx, x operand.Op) { ctx.PMOVZXDQ(mx, x) } 11070 11071// PMOVZXWD: Move Packed Word Integers to Doubleword Integers with Zero Extension. 11072// 11073// Forms: 11074// 11075// PMOVZXWD xmm xmm 11076// PMOVZXWD m64 xmm 11077// Construct and append a PMOVZXWD instruction to the active function. 11078func (c *Context) PMOVZXWD(mx, x operand.Op) { 11079 if inst, err := x86.PMOVZXWD(mx, x); err == nil { 11080 c.Instruction(inst) 11081 } else { 11082 c.adderror(err) 11083 } 11084} 11085 11086// PMOVZXWD: Move Packed Word Integers to Doubleword Integers with Zero Extension. 11087// 11088// Forms: 11089// 11090// PMOVZXWD xmm xmm 11091// PMOVZXWD m64 xmm 11092// Construct and append a PMOVZXWD instruction to the active function. 11093// Operates on the global context. 11094func PMOVZXWD(mx, x operand.Op) { ctx.PMOVZXWD(mx, x) } 11095 11096// PMOVZXWQ: Move Packed Word Integers to Quadword Integers with Zero Extension. 11097// 11098// Forms: 11099// 11100// PMOVZXWQ xmm xmm 11101// PMOVZXWQ m32 xmm 11102// Construct and append a PMOVZXWQ instruction to the active function. 11103func (c *Context) PMOVZXWQ(mx, x operand.Op) { 11104 if inst, err := x86.PMOVZXWQ(mx, x); err == nil { 11105 c.Instruction(inst) 11106 } else { 11107 c.adderror(err) 11108 } 11109} 11110 11111// PMOVZXWQ: Move Packed Word Integers to Quadword Integers with Zero Extension. 11112// 11113// Forms: 11114// 11115// PMOVZXWQ xmm xmm 11116// PMOVZXWQ m32 xmm 11117// Construct and append a PMOVZXWQ instruction to the active function. 11118// Operates on the global context. 11119func PMOVZXWQ(mx, x operand.Op) { ctx.PMOVZXWQ(mx, x) } 11120 11121// PMULDQ: Multiply Packed Signed Doubleword Integers and Store Quadword Result. 11122// 11123// Forms: 11124// 11125// PMULDQ xmm xmm 11126// PMULDQ m128 xmm 11127// Construct and append a PMULDQ instruction to the active function. 11128func (c *Context) PMULDQ(mx, x operand.Op) { 11129 if inst, err := x86.PMULDQ(mx, x); err == nil { 11130 c.Instruction(inst) 11131 } else { 11132 c.adderror(err) 11133 } 11134} 11135 11136// PMULDQ: Multiply Packed Signed Doubleword Integers and Store Quadword Result. 11137// 11138// Forms: 11139// 11140// PMULDQ xmm xmm 11141// PMULDQ m128 xmm 11142// Construct and append a PMULDQ instruction to the active function. 11143// Operates on the global context. 11144func PMULDQ(mx, x operand.Op) { ctx.PMULDQ(mx, x) } 11145 11146// PMULHRSW: Packed Multiply Signed Word Integers and Store High Result with Round and Scale. 11147// 11148// Forms: 11149// 11150// PMULHRSW xmm xmm 11151// PMULHRSW m128 xmm 11152// Construct and append a PMULHRSW instruction to the active function. 11153func (c *Context) PMULHRSW(mx, x operand.Op) { 11154 if inst, err := x86.PMULHRSW(mx, x); err == nil { 11155 c.Instruction(inst) 11156 } else { 11157 c.adderror(err) 11158 } 11159} 11160 11161// PMULHRSW: Packed Multiply Signed Word Integers and Store High Result with Round and Scale. 11162// 11163// Forms: 11164// 11165// PMULHRSW xmm xmm 11166// PMULHRSW m128 xmm 11167// Construct and append a PMULHRSW instruction to the active function. 11168// Operates on the global context. 11169func PMULHRSW(mx, x operand.Op) { ctx.PMULHRSW(mx, x) } 11170 11171// PMULHUW: Multiply Packed Unsigned Word Integers and Store High Result. 11172// 11173// Forms: 11174// 11175// PMULHUW xmm xmm 11176// PMULHUW m128 xmm 11177// Construct and append a PMULHUW instruction to the active function. 11178func (c *Context) PMULHUW(mx, x operand.Op) { 11179 if inst, err := x86.PMULHUW(mx, x); err == nil { 11180 c.Instruction(inst) 11181 } else { 11182 c.adderror(err) 11183 } 11184} 11185 11186// PMULHUW: Multiply Packed Unsigned Word Integers and Store High Result. 11187// 11188// Forms: 11189// 11190// PMULHUW xmm xmm 11191// PMULHUW m128 xmm 11192// Construct and append a PMULHUW instruction to the active function. 11193// Operates on the global context. 11194func PMULHUW(mx, x operand.Op) { ctx.PMULHUW(mx, x) } 11195 11196// PMULHW: Multiply Packed Signed Word Integers and Store High Result. 11197// 11198// Forms: 11199// 11200// PMULHW xmm xmm 11201// PMULHW m128 xmm 11202// Construct and append a PMULHW instruction to the active function. 11203func (c *Context) PMULHW(mx, x operand.Op) { 11204 if inst, err := x86.PMULHW(mx, x); err == nil { 11205 c.Instruction(inst) 11206 } else { 11207 c.adderror(err) 11208 } 11209} 11210 11211// PMULHW: Multiply Packed Signed Word Integers and Store High Result. 11212// 11213// Forms: 11214// 11215// PMULHW xmm xmm 11216// PMULHW m128 xmm 11217// Construct and append a PMULHW instruction to the active function. 11218// Operates on the global context. 11219func PMULHW(mx, x operand.Op) { ctx.PMULHW(mx, x) } 11220 11221// PMULLD: Multiply Packed Signed Doubleword Integers and Store Low Result. 11222// 11223// Forms: 11224// 11225// PMULLD xmm xmm 11226// PMULLD m128 xmm 11227// Construct and append a PMULLD instruction to the active function. 11228func (c *Context) PMULLD(mx, x operand.Op) { 11229 if inst, err := x86.PMULLD(mx, x); err == nil { 11230 c.Instruction(inst) 11231 } else { 11232 c.adderror(err) 11233 } 11234} 11235 11236// PMULLD: Multiply Packed Signed Doubleword Integers and Store Low Result. 11237// 11238// Forms: 11239// 11240// PMULLD xmm xmm 11241// PMULLD m128 xmm 11242// Construct and append a PMULLD instruction to the active function. 11243// Operates on the global context. 11244func PMULLD(mx, x operand.Op) { ctx.PMULLD(mx, x) } 11245 11246// PMULLW: Multiply Packed Signed Word Integers and Store Low Result. 11247// 11248// Forms: 11249// 11250// PMULLW xmm xmm 11251// PMULLW m128 xmm 11252// Construct and append a PMULLW instruction to the active function. 11253func (c *Context) PMULLW(mx, x operand.Op) { 11254 if inst, err := x86.PMULLW(mx, x); err == nil { 11255 c.Instruction(inst) 11256 } else { 11257 c.adderror(err) 11258 } 11259} 11260 11261// PMULLW: Multiply Packed Signed Word Integers and Store Low Result. 11262// 11263// Forms: 11264// 11265// PMULLW xmm xmm 11266// PMULLW m128 xmm 11267// Construct and append a PMULLW instruction to the active function. 11268// Operates on the global context. 11269func PMULLW(mx, x operand.Op) { ctx.PMULLW(mx, x) } 11270 11271// PMULULQ: Multiply Packed Unsigned Doubleword Integers. 11272// 11273// Forms: 11274// 11275// PMULULQ xmm xmm 11276// PMULULQ m128 xmm 11277// Construct and append a PMULULQ instruction to the active function. 11278func (c *Context) PMULULQ(mx, x operand.Op) { 11279 if inst, err := x86.PMULULQ(mx, x); err == nil { 11280 c.Instruction(inst) 11281 } else { 11282 c.adderror(err) 11283 } 11284} 11285 11286// PMULULQ: Multiply Packed Unsigned Doubleword Integers. 11287// 11288// Forms: 11289// 11290// PMULULQ xmm xmm 11291// PMULULQ m128 xmm 11292// Construct and append a PMULULQ instruction to the active function. 11293// Operates on the global context. 11294func PMULULQ(mx, x operand.Op) { ctx.PMULULQ(mx, x) } 11295 11296// POPCNTL: Count of Number of Bits Set to 1. 11297// 11298// Forms: 11299// 11300// POPCNTL r32 r32 11301// POPCNTL m32 r32 11302// Construct and append a POPCNTL instruction to the active function. 11303func (c *Context) POPCNTL(mr, r operand.Op) { 11304 if inst, err := x86.POPCNTL(mr, r); err == nil { 11305 c.Instruction(inst) 11306 } else { 11307 c.adderror(err) 11308 } 11309} 11310 11311// POPCNTL: Count of Number of Bits Set to 1. 11312// 11313// Forms: 11314// 11315// POPCNTL r32 r32 11316// POPCNTL m32 r32 11317// Construct and append a POPCNTL instruction to the active function. 11318// Operates on the global context. 11319func POPCNTL(mr, r operand.Op) { ctx.POPCNTL(mr, r) } 11320 11321// POPCNTQ: Count of Number of Bits Set to 1. 11322// 11323// Forms: 11324// 11325// POPCNTQ r64 r64 11326// POPCNTQ m64 r64 11327// Construct and append a POPCNTQ instruction to the active function. 11328func (c *Context) POPCNTQ(mr, r operand.Op) { 11329 if inst, err := x86.POPCNTQ(mr, r); err == nil { 11330 c.Instruction(inst) 11331 } else { 11332 c.adderror(err) 11333 } 11334} 11335 11336// POPCNTQ: Count of Number of Bits Set to 1. 11337// 11338// Forms: 11339// 11340// POPCNTQ r64 r64 11341// POPCNTQ m64 r64 11342// Construct and append a POPCNTQ instruction to the active function. 11343// Operates on the global context. 11344func POPCNTQ(mr, r operand.Op) { ctx.POPCNTQ(mr, r) } 11345 11346// POPCNTW: Count of Number of Bits Set to 1. 11347// 11348// Forms: 11349// 11350// POPCNTW r16 r16 11351// POPCNTW m16 r16 11352// Construct and append a POPCNTW instruction to the active function. 11353func (c *Context) POPCNTW(mr, r operand.Op) { 11354 if inst, err := x86.POPCNTW(mr, r); err == nil { 11355 c.Instruction(inst) 11356 } else { 11357 c.adderror(err) 11358 } 11359} 11360 11361// POPCNTW: Count of Number of Bits Set to 1. 11362// 11363// Forms: 11364// 11365// POPCNTW r16 r16 11366// POPCNTW m16 r16 11367// Construct and append a POPCNTW instruction to the active function. 11368// Operates on the global context. 11369func POPCNTW(mr, r operand.Op) { ctx.POPCNTW(mr, r) } 11370 11371// POPQ: Pop a Value from the Stack. 11372// 11373// Forms: 11374// 11375// POPQ r64 11376// POPQ m64 11377// Construct and append a POPQ instruction to the active function. 11378func (c *Context) POPQ(mr operand.Op) { 11379 if inst, err := x86.POPQ(mr); err == nil { 11380 c.Instruction(inst) 11381 } else { 11382 c.adderror(err) 11383 } 11384} 11385 11386// POPQ: Pop a Value from the Stack. 11387// 11388// Forms: 11389// 11390// POPQ r64 11391// POPQ m64 11392// Construct and append a POPQ instruction to the active function. 11393// Operates on the global context. 11394func POPQ(mr operand.Op) { ctx.POPQ(mr) } 11395 11396// POPW: Pop a Value from the Stack. 11397// 11398// Forms: 11399// 11400// POPW r16 11401// POPW m16 11402// Construct and append a POPW instruction to the active function. 11403func (c *Context) POPW(mr operand.Op) { 11404 if inst, err := x86.POPW(mr); err == nil { 11405 c.Instruction(inst) 11406 } else { 11407 c.adderror(err) 11408 } 11409} 11410 11411// POPW: Pop a Value from the Stack. 11412// 11413// Forms: 11414// 11415// POPW r16 11416// POPW m16 11417// Construct and append a POPW instruction to the active function. 11418// Operates on the global context. 11419func POPW(mr operand.Op) { ctx.POPW(mr) } 11420 11421// POR: Packed Bitwise Logical OR. 11422// 11423// Forms: 11424// 11425// POR xmm xmm 11426// POR m128 xmm 11427// Construct and append a POR instruction to the active function. 11428func (c *Context) POR(mx, x operand.Op) { 11429 if inst, err := x86.POR(mx, x); err == nil { 11430 c.Instruction(inst) 11431 } else { 11432 c.adderror(err) 11433 } 11434} 11435 11436// POR: Packed Bitwise Logical OR. 11437// 11438// Forms: 11439// 11440// POR xmm xmm 11441// POR m128 xmm 11442// Construct and append a POR instruction to the active function. 11443// Operates on the global context. 11444func POR(mx, x operand.Op) { ctx.POR(mx, x) } 11445 11446// PREFETCHNTA: Prefetch Data Into Caches using NTA Hint. 11447// 11448// Forms: 11449// 11450// PREFETCHNTA m8 11451// Construct and append a PREFETCHNTA instruction to the active function. 11452func (c *Context) PREFETCHNTA(m operand.Op) { 11453 if inst, err := x86.PREFETCHNTA(m); err == nil { 11454 c.Instruction(inst) 11455 } else { 11456 c.adderror(err) 11457 } 11458} 11459 11460// PREFETCHNTA: Prefetch Data Into Caches using NTA Hint. 11461// 11462// Forms: 11463// 11464// PREFETCHNTA m8 11465// Construct and append a PREFETCHNTA instruction to the active function. 11466// Operates on the global context. 11467func PREFETCHNTA(m operand.Op) { ctx.PREFETCHNTA(m) } 11468 11469// PREFETCHT0: Prefetch Data Into Caches using T0 Hint. 11470// 11471// Forms: 11472// 11473// PREFETCHT0 m8 11474// Construct and append a PREFETCHT0 instruction to the active function. 11475func (c *Context) PREFETCHT0(m operand.Op) { 11476 if inst, err := x86.PREFETCHT0(m); err == nil { 11477 c.Instruction(inst) 11478 } else { 11479 c.adderror(err) 11480 } 11481} 11482 11483// PREFETCHT0: Prefetch Data Into Caches using T0 Hint. 11484// 11485// Forms: 11486// 11487// PREFETCHT0 m8 11488// Construct and append a PREFETCHT0 instruction to the active function. 11489// Operates on the global context. 11490func PREFETCHT0(m operand.Op) { ctx.PREFETCHT0(m) } 11491 11492// PREFETCHT1: Prefetch Data Into Caches using T1 Hint. 11493// 11494// Forms: 11495// 11496// PREFETCHT1 m8 11497// Construct and append a PREFETCHT1 instruction to the active function. 11498func (c *Context) PREFETCHT1(m operand.Op) { 11499 if inst, err := x86.PREFETCHT1(m); err == nil { 11500 c.Instruction(inst) 11501 } else { 11502 c.adderror(err) 11503 } 11504} 11505 11506// PREFETCHT1: Prefetch Data Into Caches using T1 Hint. 11507// 11508// Forms: 11509// 11510// PREFETCHT1 m8 11511// Construct and append a PREFETCHT1 instruction to the active function. 11512// Operates on the global context. 11513func PREFETCHT1(m operand.Op) { ctx.PREFETCHT1(m) } 11514 11515// PREFETCHT2: Prefetch Data Into Caches using T2 Hint. 11516// 11517// Forms: 11518// 11519// PREFETCHT2 m8 11520// Construct and append a PREFETCHT2 instruction to the active function. 11521func (c *Context) PREFETCHT2(m operand.Op) { 11522 if inst, err := x86.PREFETCHT2(m); err == nil { 11523 c.Instruction(inst) 11524 } else { 11525 c.adderror(err) 11526 } 11527} 11528 11529// PREFETCHT2: Prefetch Data Into Caches using T2 Hint. 11530// 11531// Forms: 11532// 11533// PREFETCHT2 m8 11534// Construct and append a PREFETCHT2 instruction to the active function. 11535// Operates on the global context. 11536func PREFETCHT2(m operand.Op) { ctx.PREFETCHT2(m) } 11537 11538// PSADBW: Compute Sum of Absolute Differences. 11539// 11540// Forms: 11541// 11542// PSADBW xmm xmm 11543// PSADBW m128 xmm 11544// Construct and append a PSADBW instruction to the active function. 11545func (c *Context) PSADBW(mx, x operand.Op) { 11546 if inst, err := x86.PSADBW(mx, x); err == nil { 11547 c.Instruction(inst) 11548 } else { 11549 c.adderror(err) 11550 } 11551} 11552 11553// PSADBW: Compute Sum of Absolute Differences. 11554// 11555// Forms: 11556// 11557// PSADBW xmm xmm 11558// PSADBW m128 xmm 11559// Construct and append a PSADBW instruction to the active function. 11560// Operates on the global context. 11561func PSADBW(mx, x operand.Op) { ctx.PSADBW(mx, x) } 11562 11563// PSHUFB: Packed Shuffle Bytes. 11564// 11565// Forms: 11566// 11567// PSHUFB xmm xmm 11568// PSHUFB m128 xmm 11569// Construct and append a PSHUFB instruction to the active function. 11570func (c *Context) PSHUFB(mx, x operand.Op) { 11571 if inst, err := x86.PSHUFB(mx, x); err == nil { 11572 c.Instruction(inst) 11573 } else { 11574 c.adderror(err) 11575 } 11576} 11577 11578// PSHUFB: Packed Shuffle Bytes. 11579// 11580// Forms: 11581// 11582// PSHUFB xmm xmm 11583// PSHUFB m128 xmm 11584// Construct and append a PSHUFB instruction to the active function. 11585// Operates on the global context. 11586func PSHUFB(mx, x operand.Op) { ctx.PSHUFB(mx, x) } 11587 11588// PSHUFD: Shuffle Packed Doublewords. 11589// 11590// Forms: 11591// 11592// PSHUFD imm8 xmm xmm 11593// PSHUFD imm8 m128 xmm 11594// Construct and append a PSHUFD instruction to the active function. 11595func (c *Context) PSHUFD(i, mx, x operand.Op) { 11596 if inst, err := x86.PSHUFD(i, mx, x); err == nil { 11597 c.Instruction(inst) 11598 } else { 11599 c.adderror(err) 11600 } 11601} 11602 11603// PSHUFD: Shuffle Packed Doublewords. 11604// 11605// Forms: 11606// 11607// PSHUFD imm8 xmm xmm 11608// PSHUFD imm8 m128 xmm 11609// Construct and append a PSHUFD instruction to the active function. 11610// Operates on the global context. 11611func PSHUFD(i, mx, x operand.Op) { ctx.PSHUFD(i, mx, x) } 11612 11613// PSHUFHW: Shuffle Packed High Words. 11614// 11615// Forms: 11616// 11617// PSHUFHW imm8 xmm xmm 11618// PSHUFHW imm8 m128 xmm 11619// Construct and append a PSHUFHW instruction to the active function. 11620func (c *Context) PSHUFHW(i, mx, x operand.Op) { 11621 if inst, err := x86.PSHUFHW(i, mx, x); err == nil { 11622 c.Instruction(inst) 11623 } else { 11624 c.adderror(err) 11625 } 11626} 11627 11628// PSHUFHW: Shuffle Packed High Words. 11629// 11630// Forms: 11631// 11632// PSHUFHW imm8 xmm xmm 11633// PSHUFHW imm8 m128 xmm 11634// Construct and append a PSHUFHW instruction to the active function. 11635// Operates on the global context. 11636func PSHUFHW(i, mx, x operand.Op) { ctx.PSHUFHW(i, mx, x) } 11637 11638// PSHUFL: Shuffle Packed Doublewords. 11639// 11640// Forms: 11641// 11642// PSHUFL imm8 xmm xmm 11643// PSHUFL imm8 m128 xmm 11644// Construct and append a PSHUFL instruction to the active function. 11645func (c *Context) PSHUFL(i, mx, x operand.Op) { 11646 if inst, err := x86.PSHUFL(i, mx, x); err == nil { 11647 c.Instruction(inst) 11648 } else { 11649 c.adderror(err) 11650 } 11651} 11652 11653// PSHUFL: Shuffle Packed Doublewords. 11654// 11655// Forms: 11656// 11657// PSHUFL imm8 xmm xmm 11658// PSHUFL imm8 m128 xmm 11659// Construct and append a PSHUFL instruction to the active function. 11660// Operates on the global context. 11661func PSHUFL(i, mx, x operand.Op) { ctx.PSHUFL(i, mx, x) } 11662 11663// PSHUFLW: Shuffle Packed Low Words. 11664// 11665// Forms: 11666// 11667// PSHUFLW imm8 xmm xmm 11668// PSHUFLW imm8 m128 xmm 11669// Construct and append a PSHUFLW instruction to the active function. 11670func (c *Context) PSHUFLW(i, mx, x operand.Op) { 11671 if inst, err := x86.PSHUFLW(i, mx, x); err == nil { 11672 c.Instruction(inst) 11673 } else { 11674 c.adderror(err) 11675 } 11676} 11677 11678// PSHUFLW: Shuffle Packed Low Words. 11679// 11680// Forms: 11681// 11682// PSHUFLW imm8 xmm xmm 11683// PSHUFLW imm8 m128 xmm 11684// Construct and append a PSHUFLW instruction to the active function. 11685// Operates on the global context. 11686func PSHUFLW(i, mx, x operand.Op) { ctx.PSHUFLW(i, mx, x) } 11687 11688// PSIGNB: Packed Sign of Byte Integers. 11689// 11690// Forms: 11691// 11692// PSIGNB xmm xmm 11693// PSIGNB m128 xmm 11694// Construct and append a PSIGNB instruction to the active function. 11695func (c *Context) PSIGNB(mx, x operand.Op) { 11696 if inst, err := x86.PSIGNB(mx, x); err == nil { 11697 c.Instruction(inst) 11698 } else { 11699 c.adderror(err) 11700 } 11701} 11702 11703// PSIGNB: Packed Sign of Byte Integers. 11704// 11705// Forms: 11706// 11707// PSIGNB xmm xmm 11708// PSIGNB m128 xmm 11709// Construct and append a PSIGNB instruction to the active function. 11710// Operates on the global context. 11711func PSIGNB(mx, x operand.Op) { ctx.PSIGNB(mx, x) } 11712 11713// PSIGND: Packed Sign of Doubleword Integers. 11714// 11715// Forms: 11716// 11717// PSIGND xmm xmm 11718// PSIGND m128 xmm 11719// Construct and append a PSIGND instruction to the active function. 11720func (c *Context) PSIGND(mx, x operand.Op) { 11721 if inst, err := x86.PSIGND(mx, x); err == nil { 11722 c.Instruction(inst) 11723 } else { 11724 c.adderror(err) 11725 } 11726} 11727 11728// PSIGND: Packed Sign of Doubleword Integers. 11729// 11730// Forms: 11731// 11732// PSIGND xmm xmm 11733// PSIGND m128 xmm 11734// Construct and append a PSIGND instruction to the active function. 11735// Operates on the global context. 11736func PSIGND(mx, x operand.Op) { ctx.PSIGND(mx, x) } 11737 11738// PSIGNW: Packed Sign of Word Integers. 11739// 11740// Forms: 11741// 11742// PSIGNW xmm xmm 11743// PSIGNW m128 xmm 11744// Construct and append a PSIGNW instruction to the active function. 11745func (c *Context) PSIGNW(mx, x operand.Op) { 11746 if inst, err := x86.PSIGNW(mx, x); err == nil { 11747 c.Instruction(inst) 11748 } else { 11749 c.adderror(err) 11750 } 11751} 11752 11753// PSIGNW: Packed Sign of Word Integers. 11754// 11755// Forms: 11756// 11757// PSIGNW xmm xmm 11758// PSIGNW m128 xmm 11759// Construct and append a PSIGNW instruction to the active function. 11760// Operates on the global context. 11761func PSIGNW(mx, x operand.Op) { ctx.PSIGNW(mx, x) } 11762 11763// PSLLDQ: Shift Packed Double Quadword Left Logical. 11764// 11765// Forms: 11766// 11767// PSLLDQ imm8 xmm 11768// Construct and append a PSLLDQ instruction to the active function. 11769func (c *Context) PSLLDQ(i, x operand.Op) { 11770 if inst, err := x86.PSLLDQ(i, x); err == nil { 11771 c.Instruction(inst) 11772 } else { 11773 c.adderror(err) 11774 } 11775} 11776 11777// PSLLDQ: Shift Packed Double Quadword Left Logical. 11778// 11779// Forms: 11780// 11781// PSLLDQ imm8 xmm 11782// Construct and append a PSLLDQ instruction to the active function. 11783// Operates on the global context. 11784func PSLLDQ(i, x operand.Op) { ctx.PSLLDQ(i, x) } 11785 11786// PSLLL: Shift Packed Doubleword Data Left Logical. 11787// 11788// Forms: 11789// 11790// PSLLL imm8 xmm 11791// PSLLL xmm xmm 11792// PSLLL m128 xmm 11793// Construct and append a PSLLL instruction to the active function. 11794func (c *Context) PSLLL(imx, x operand.Op) { 11795 if inst, err := x86.PSLLL(imx, x); err == nil { 11796 c.Instruction(inst) 11797 } else { 11798 c.adderror(err) 11799 } 11800} 11801 11802// PSLLL: Shift Packed Doubleword Data Left Logical. 11803// 11804// Forms: 11805// 11806// PSLLL imm8 xmm 11807// PSLLL xmm xmm 11808// PSLLL m128 xmm 11809// Construct and append a PSLLL instruction to the active function. 11810// Operates on the global context. 11811func PSLLL(imx, x operand.Op) { ctx.PSLLL(imx, x) } 11812 11813// PSLLO: Shift Packed Double Quadword Left Logical. 11814// 11815// Forms: 11816// 11817// PSLLO imm8 xmm 11818// Construct and append a PSLLO instruction to the active function. 11819func (c *Context) PSLLO(i, x operand.Op) { 11820 if inst, err := x86.PSLLO(i, x); err == nil { 11821 c.Instruction(inst) 11822 } else { 11823 c.adderror(err) 11824 } 11825} 11826 11827// PSLLO: Shift Packed Double Quadword Left Logical. 11828// 11829// Forms: 11830// 11831// PSLLO imm8 xmm 11832// Construct and append a PSLLO instruction to the active function. 11833// Operates on the global context. 11834func PSLLO(i, x operand.Op) { ctx.PSLLO(i, x) } 11835 11836// PSLLQ: Shift Packed Quadword Data Left Logical. 11837// 11838// Forms: 11839// 11840// PSLLQ imm8 xmm 11841// PSLLQ xmm xmm 11842// PSLLQ m128 xmm 11843// Construct and append a PSLLQ instruction to the active function. 11844func (c *Context) PSLLQ(imx, x operand.Op) { 11845 if inst, err := x86.PSLLQ(imx, x); err == nil { 11846 c.Instruction(inst) 11847 } else { 11848 c.adderror(err) 11849 } 11850} 11851 11852// PSLLQ: Shift Packed Quadword Data Left Logical. 11853// 11854// Forms: 11855// 11856// PSLLQ imm8 xmm 11857// PSLLQ xmm xmm 11858// PSLLQ m128 xmm 11859// Construct and append a PSLLQ instruction to the active function. 11860// Operates on the global context. 11861func PSLLQ(imx, x operand.Op) { ctx.PSLLQ(imx, x) } 11862 11863// PSLLW: Shift Packed Word Data Left Logical. 11864// 11865// Forms: 11866// 11867// PSLLW imm8 xmm 11868// PSLLW xmm xmm 11869// PSLLW m128 xmm 11870// Construct and append a PSLLW instruction to the active function. 11871func (c *Context) PSLLW(imx, x operand.Op) { 11872 if inst, err := x86.PSLLW(imx, x); err == nil { 11873 c.Instruction(inst) 11874 } else { 11875 c.adderror(err) 11876 } 11877} 11878 11879// PSLLW: Shift Packed Word Data Left Logical. 11880// 11881// Forms: 11882// 11883// PSLLW imm8 xmm 11884// PSLLW xmm xmm 11885// PSLLW m128 xmm 11886// Construct and append a PSLLW instruction to the active function. 11887// Operates on the global context. 11888func PSLLW(imx, x operand.Op) { ctx.PSLLW(imx, x) } 11889 11890// PSRAL: Shift Packed Doubleword Data Right Arithmetic. 11891// 11892// Forms: 11893// 11894// PSRAL imm8 xmm 11895// PSRAL xmm xmm 11896// PSRAL m128 xmm 11897// Construct and append a PSRAL instruction to the active function. 11898func (c *Context) PSRAL(imx, x operand.Op) { 11899 if inst, err := x86.PSRAL(imx, x); err == nil { 11900 c.Instruction(inst) 11901 } else { 11902 c.adderror(err) 11903 } 11904} 11905 11906// PSRAL: Shift Packed Doubleword Data Right Arithmetic. 11907// 11908// Forms: 11909// 11910// PSRAL imm8 xmm 11911// PSRAL xmm xmm 11912// PSRAL m128 xmm 11913// Construct and append a PSRAL instruction to the active function. 11914// Operates on the global context. 11915func PSRAL(imx, x operand.Op) { ctx.PSRAL(imx, x) } 11916 11917// PSRAW: Shift Packed Word Data Right Arithmetic. 11918// 11919// Forms: 11920// 11921// PSRAW imm8 xmm 11922// PSRAW xmm xmm 11923// PSRAW m128 xmm 11924// Construct and append a PSRAW instruction to the active function. 11925func (c *Context) PSRAW(imx, x operand.Op) { 11926 if inst, err := x86.PSRAW(imx, x); err == nil { 11927 c.Instruction(inst) 11928 } else { 11929 c.adderror(err) 11930 } 11931} 11932 11933// PSRAW: Shift Packed Word Data Right Arithmetic. 11934// 11935// Forms: 11936// 11937// PSRAW imm8 xmm 11938// PSRAW xmm xmm 11939// PSRAW m128 xmm 11940// Construct and append a PSRAW instruction to the active function. 11941// Operates on the global context. 11942func PSRAW(imx, x operand.Op) { ctx.PSRAW(imx, x) } 11943 11944// PSRLDQ: Shift Packed Double Quadword Right Logical. 11945// 11946// Forms: 11947// 11948// PSRLDQ imm8 xmm 11949// Construct and append a PSRLDQ instruction to the active function. 11950func (c *Context) PSRLDQ(i, x operand.Op) { 11951 if inst, err := x86.PSRLDQ(i, x); err == nil { 11952 c.Instruction(inst) 11953 } else { 11954 c.adderror(err) 11955 } 11956} 11957 11958// PSRLDQ: Shift Packed Double Quadword Right Logical. 11959// 11960// Forms: 11961// 11962// PSRLDQ imm8 xmm 11963// Construct and append a PSRLDQ instruction to the active function. 11964// Operates on the global context. 11965func PSRLDQ(i, x operand.Op) { ctx.PSRLDQ(i, x) } 11966 11967// PSRLL: Shift Packed Doubleword Data Right Logical. 11968// 11969// Forms: 11970// 11971// PSRLL imm8 xmm 11972// PSRLL xmm xmm 11973// PSRLL m128 xmm 11974// Construct and append a PSRLL instruction to the active function. 11975func (c *Context) PSRLL(imx, x operand.Op) { 11976 if inst, err := x86.PSRLL(imx, x); err == nil { 11977 c.Instruction(inst) 11978 } else { 11979 c.adderror(err) 11980 } 11981} 11982 11983// PSRLL: Shift Packed Doubleword Data Right Logical. 11984// 11985// Forms: 11986// 11987// PSRLL imm8 xmm 11988// PSRLL xmm xmm 11989// PSRLL m128 xmm 11990// Construct and append a PSRLL instruction to the active function. 11991// Operates on the global context. 11992func PSRLL(imx, x operand.Op) { ctx.PSRLL(imx, x) } 11993 11994// PSRLO: Shift Packed Double Quadword Right Logical. 11995// 11996// Forms: 11997// 11998// PSRLO imm8 xmm 11999// Construct and append a PSRLO instruction to the active function. 12000func (c *Context) PSRLO(i, x operand.Op) { 12001 if inst, err := x86.PSRLO(i, x); err == nil { 12002 c.Instruction(inst) 12003 } else { 12004 c.adderror(err) 12005 } 12006} 12007 12008// PSRLO: Shift Packed Double Quadword Right Logical. 12009// 12010// Forms: 12011// 12012// PSRLO imm8 xmm 12013// Construct and append a PSRLO instruction to the active function. 12014// Operates on the global context. 12015func PSRLO(i, x operand.Op) { ctx.PSRLO(i, x) } 12016 12017// PSRLQ: Shift Packed Quadword Data Right Logical. 12018// 12019// Forms: 12020// 12021// PSRLQ imm8 xmm 12022// PSRLQ xmm xmm 12023// PSRLQ m128 xmm 12024// Construct and append a PSRLQ instruction to the active function. 12025func (c *Context) PSRLQ(imx, x operand.Op) { 12026 if inst, err := x86.PSRLQ(imx, x); err == nil { 12027 c.Instruction(inst) 12028 } else { 12029 c.adderror(err) 12030 } 12031} 12032 12033// PSRLQ: Shift Packed Quadword Data Right Logical. 12034// 12035// Forms: 12036// 12037// PSRLQ imm8 xmm 12038// PSRLQ xmm xmm 12039// PSRLQ m128 xmm 12040// Construct and append a PSRLQ instruction to the active function. 12041// Operates on the global context. 12042func PSRLQ(imx, x operand.Op) { ctx.PSRLQ(imx, x) } 12043 12044// PSRLW: Shift Packed Word Data Right Logical. 12045// 12046// Forms: 12047// 12048// PSRLW imm8 xmm 12049// PSRLW xmm xmm 12050// PSRLW m128 xmm 12051// Construct and append a PSRLW instruction to the active function. 12052func (c *Context) PSRLW(imx, x operand.Op) { 12053 if inst, err := x86.PSRLW(imx, x); err == nil { 12054 c.Instruction(inst) 12055 } else { 12056 c.adderror(err) 12057 } 12058} 12059 12060// PSRLW: Shift Packed Word Data Right Logical. 12061// 12062// Forms: 12063// 12064// PSRLW imm8 xmm 12065// PSRLW xmm xmm 12066// PSRLW m128 xmm 12067// Construct and append a PSRLW instruction to the active function. 12068// Operates on the global context. 12069func PSRLW(imx, x operand.Op) { ctx.PSRLW(imx, x) } 12070 12071// PSUBB: Subtract Packed Byte Integers. 12072// 12073// Forms: 12074// 12075// PSUBB xmm xmm 12076// PSUBB m128 xmm 12077// Construct and append a PSUBB instruction to the active function. 12078func (c *Context) PSUBB(mx, x operand.Op) { 12079 if inst, err := x86.PSUBB(mx, x); err == nil { 12080 c.Instruction(inst) 12081 } else { 12082 c.adderror(err) 12083 } 12084} 12085 12086// PSUBB: Subtract Packed Byte Integers. 12087// 12088// Forms: 12089// 12090// PSUBB xmm xmm 12091// PSUBB m128 xmm 12092// Construct and append a PSUBB instruction to the active function. 12093// Operates on the global context. 12094func PSUBB(mx, x operand.Op) { ctx.PSUBB(mx, x) } 12095 12096// PSUBL: Subtract Packed Doubleword Integers. 12097// 12098// Forms: 12099// 12100// PSUBL xmm xmm 12101// PSUBL m128 xmm 12102// Construct and append a PSUBL instruction to the active function. 12103func (c *Context) PSUBL(mx, x operand.Op) { 12104 if inst, err := x86.PSUBL(mx, x); err == nil { 12105 c.Instruction(inst) 12106 } else { 12107 c.adderror(err) 12108 } 12109} 12110 12111// PSUBL: Subtract Packed Doubleword Integers. 12112// 12113// Forms: 12114// 12115// PSUBL xmm xmm 12116// PSUBL m128 xmm 12117// Construct and append a PSUBL instruction to the active function. 12118// Operates on the global context. 12119func PSUBL(mx, x operand.Op) { ctx.PSUBL(mx, x) } 12120 12121// PSUBQ: Subtract Packed Quadword Integers. 12122// 12123// Forms: 12124// 12125// PSUBQ xmm xmm 12126// PSUBQ m128 xmm 12127// Construct and append a PSUBQ instruction to the active function. 12128func (c *Context) PSUBQ(mx, x operand.Op) { 12129 if inst, err := x86.PSUBQ(mx, x); err == nil { 12130 c.Instruction(inst) 12131 } else { 12132 c.adderror(err) 12133 } 12134} 12135 12136// PSUBQ: Subtract Packed Quadword Integers. 12137// 12138// Forms: 12139// 12140// PSUBQ xmm xmm 12141// PSUBQ m128 xmm 12142// Construct and append a PSUBQ instruction to the active function. 12143// Operates on the global context. 12144func PSUBQ(mx, x operand.Op) { ctx.PSUBQ(mx, x) } 12145 12146// PSUBSB: Subtract Packed Signed Byte Integers with Signed Saturation. 12147// 12148// Forms: 12149// 12150// PSUBSB xmm xmm 12151// PSUBSB m128 xmm 12152// Construct and append a PSUBSB instruction to the active function. 12153func (c *Context) PSUBSB(mx, x operand.Op) { 12154 if inst, err := x86.PSUBSB(mx, x); err == nil { 12155 c.Instruction(inst) 12156 } else { 12157 c.adderror(err) 12158 } 12159} 12160 12161// PSUBSB: Subtract Packed Signed Byte Integers with Signed Saturation. 12162// 12163// Forms: 12164// 12165// PSUBSB xmm xmm 12166// PSUBSB m128 xmm 12167// Construct and append a PSUBSB instruction to the active function. 12168// Operates on the global context. 12169func PSUBSB(mx, x operand.Op) { ctx.PSUBSB(mx, x) } 12170 12171// PSUBSW: Subtract Packed Signed Word Integers with Signed Saturation. 12172// 12173// Forms: 12174// 12175// PSUBSW xmm xmm 12176// PSUBSW m128 xmm 12177// Construct and append a PSUBSW instruction to the active function. 12178func (c *Context) PSUBSW(mx, x operand.Op) { 12179 if inst, err := x86.PSUBSW(mx, x); err == nil { 12180 c.Instruction(inst) 12181 } else { 12182 c.adderror(err) 12183 } 12184} 12185 12186// PSUBSW: Subtract Packed Signed Word Integers with Signed Saturation. 12187// 12188// Forms: 12189// 12190// PSUBSW xmm xmm 12191// PSUBSW m128 xmm 12192// Construct and append a PSUBSW instruction to the active function. 12193// Operates on the global context. 12194func PSUBSW(mx, x operand.Op) { ctx.PSUBSW(mx, x) } 12195 12196// PSUBUSB: Subtract Packed Unsigned Byte Integers with Unsigned Saturation. 12197// 12198// Forms: 12199// 12200// PSUBUSB xmm xmm 12201// PSUBUSB m128 xmm 12202// Construct and append a PSUBUSB instruction to the active function. 12203func (c *Context) PSUBUSB(mx, x operand.Op) { 12204 if inst, err := x86.PSUBUSB(mx, x); err == nil { 12205 c.Instruction(inst) 12206 } else { 12207 c.adderror(err) 12208 } 12209} 12210 12211// PSUBUSB: Subtract Packed Unsigned Byte Integers with Unsigned Saturation. 12212// 12213// Forms: 12214// 12215// PSUBUSB xmm xmm 12216// PSUBUSB m128 xmm 12217// Construct and append a PSUBUSB instruction to the active function. 12218// Operates on the global context. 12219func PSUBUSB(mx, x operand.Op) { ctx.PSUBUSB(mx, x) } 12220 12221// PSUBUSW: Subtract Packed Unsigned Word Integers with Unsigned Saturation. 12222// 12223// Forms: 12224// 12225// PSUBUSW xmm xmm 12226// PSUBUSW m128 xmm 12227// Construct and append a PSUBUSW instruction to the active function. 12228func (c *Context) PSUBUSW(mx, x operand.Op) { 12229 if inst, err := x86.PSUBUSW(mx, x); err == nil { 12230 c.Instruction(inst) 12231 } else { 12232 c.adderror(err) 12233 } 12234} 12235 12236// PSUBUSW: Subtract Packed Unsigned Word Integers with Unsigned Saturation. 12237// 12238// Forms: 12239// 12240// PSUBUSW xmm xmm 12241// PSUBUSW m128 xmm 12242// Construct and append a PSUBUSW instruction to the active function. 12243// Operates on the global context. 12244func PSUBUSW(mx, x operand.Op) { ctx.PSUBUSW(mx, x) } 12245 12246// PSUBW: Subtract Packed Word Integers. 12247// 12248// Forms: 12249// 12250// PSUBW xmm xmm 12251// PSUBW m128 xmm 12252// Construct and append a PSUBW instruction to the active function. 12253func (c *Context) PSUBW(mx, x operand.Op) { 12254 if inst, err := x86.PSUBW(mx, x); err == nil { 12255 c.Instruction(inst) 12256 } else { 12257 c.adderror(err) 12258 } 12259} 12260 12261// PSUBW: Subtract Packed Word Integers. 12262// 12263// Forms: 12264// 12265// PSUBW xmm xmm 12266// PSUBW m128 xmm 12267// Construct and append a PSUBW instruction to the active function. 12268// Operates on the global context. 12269func PSUBW(mx, x operand.Op) { ctx.PSUBW(mx, x) } 12270 12271// PTEST: Packed Logical Compare. 12272// 12273// Forms: 12274// 12275// PTEST xmm xmm 12276// PTEST m128 xmm 12277// Construct and append a PTEST instruction to the active function. 12278func (c *Context) PTEST(mx, x operand.Op) { 12279 if inst, err := x86.PTEST(mx, x); err == nil { 12280 c.Instruction(inst) 12281 } else { 12282 c.adderror(err) 12283 } 12284} 12285 12286// PTEST: Packed Logical Compare. 12287// 12288// Forms: 12289// 12290// PTEST xmm xmm 12291// PTEST m128 xmm 12292// Construct and append a PTEST instruction to the active function. 12293// Operates on the global context. 12294func PTEST(mx, x operand.Op) { ctx.PTEST(mx, x) } 12295 12296// PUNPCKHBW: Unpack and Interleave High-Order Bytes into Words. 12297// 12298// Forms: 12299// 12300// PUNPCKHBW xmm xmm 12301// PUNPCKHBW m128 xmm 12302// Construct and append a PUNPCKHBW instruction to the active function. 12303func (c *Context) PUNPCKHBW(mx, x operand.Op) { 12304 if inst, err := x86.PUNPCKHBW(mx, x); err == nil { 12305 c.Instruction(inst) 12306 } else { 12307 c.adderror(err) 12308 } 12309} 12310 12311// PUNPCKHBW: Unpack and Interleave High-Order Bytes into Words. 12312// 12313// Forms: 12314// 12315// PUNPCKHBW xmm xmm 12316// PUNPCKHBW m128 xmm 12317// Construct and append a PUNPCKHBW instruction to the active function. 12318// Operates on the global context. 12319func PUNPCKHBW(mx, x operand.Op) { ctx.PUNPCKHBW(mx, x) } 12320 12321// PUNPCKHLQ: Unpack and Interleave High-Order Doublewords into Quadwords. 12322// 12323// Forms: 12324// 12325// PUNPCKHLQ xmm xmm 12326// PUNPCKHLQ m128 xmm 12327// Construct and append a PUNPCKHLQ instruction to the active function. 12328func (c *Context) PUNPCKHLQ(mx, x operand.Op) { 12329 if inst, err := x86.PUNPCKHLQ(mx, x); err == nil { 12330 c.Instruction(inst) 12331 } else { 12332 c.adderror(err) 12333 } 12334} 12335 12336// PUNPCKHLQ: Unpack and Interleave High-Order Doublewords into Quadwords. 12337// 12338// Forms: 12339// 12340// PUNPCKHLQ xmm xmm 12341// PUNPCKHLQ m128 xmm 12342// Construct and append a PUNPCKHLQ instruction to the active function. 12343// Operates on the global context. 12344func PUNPCKHLQ(mx, x operand.Op) { ctx.PUNPCKHLQ(mx, x) } 12345 12346// PUNPCKHQDQ: Unpack and Interleave High-Order Quadwords into Double Quadwords. 12347// 12348// Forms: 12349// 12350// PUNPCKHQDQ xmm xmm 12351// PUNPCKHQDQ m128 xmm 12352// Construct and append a PUNPCKHQDQ instruction to the active function. 12353func (c *Context) PUNPCKHQDQ(mx, x operand.Op) { 12354 if inst, err := x86.PUNPCKHQDQ(mx, x); err == nil { 12355 c.Instruction(inst) 12356 } else { 12357 c.adderror(err) 12358 } 12359} 12360 12361// PUNPCKHQDQ: Unpack and Interleave High-Order Quadwords into Double Quadwords. 12362// 12363// Forms: 12364// 12365// PUNPCKHQDQ xmm xmm 12366// PUNPCKHQDQ m128 xmm 12367// Construct and append a PUNPCKHQDQ instruction to the active function. 12368// Operates on the global context. 12369func PUNPCKHQDQ(mx, x operand.Op) { ctx.PUNPCKHQDQ(mx, x) } 12370 12371// PUNPCKHWL: Unpack and Interleave High-Order Words into Doublewords. 12372// 12373// Forms: 12374// 12375// PUNPCKHWL xmm xmm 12376// PUNPCKHWL m128 xmm 12377// Construct and append a PUNPCKHWL instruction to the active function. 12378func (c *Context) PUNPCKHWL(mx, x operand.Op) { 12379 if inst, err := x86.PUNPCKHWL(mx, x); err == nil { 12380 c.Instruction(inst) 12381 } else { 12382 c.adderror(err) 12383 } 12384} 12385 12386// PUNPCKHWL: Unpack and Interleave High-Order Words into Doublewords. 12387// 12388// Forms: 12389// 12390// PUNPCKHWL xmm xmm 12391// PUNPCKHWL m128 xmm 12392// Construct and append a PUNPCKHWL instruction to the active function. 12393// Operates on the global context. 12394func PUNPCKHWL(mx, x operand.Op) { ctx.PUNPCKHWL(mx, x) } 12395 12396// PUNPCKLBW: Unpack and Interleave Low-Order Bytes into Words. 12397// 12398// Forms: 12399// 12400// PUNPCKLBW xmm xmm 12401// PUNPCKLBW m128 xmm 12402// Construct and append a PUNPCKLBW instruction to the active function. 12403func (c *Context) PUNPCKLBW(mx, x operand.Op) { 12404 if inst, err := x86.PUNPCKLBW(mx, x); err == nil { 12405 c.Instruction(inst) 12406 } else { 12407 c.adderror(err) 12408 } 12409} 12410 12411// PUNPCKLBW: Unpack and Interleave Low-Order Bytes into Words. 12412// 12413// Forms: 12414// 12415// PUNPCKLBW xmm xmm 12416// PUNPCKLBW m128 xmm 12417// Construct and append a PUNPCKLBW instruction to the active function. 12418// Operates on the global context. 12419func PUNPCKLBW(mx, x operand.Op) { ctx.PUNPCKLBW(mx, x) } 12420 12421// PUNPCKLLQ: Unpack and Interleave Low-Order Doublewords into Quadwords. 12422// 12423// Forms: 12424// 12425// PUNPCKLLQ xmm xmm 12426// PUNPCKLLQ m128 xmm 12427// Construct and append a PUNPCKLLQ instruction to the active function. 12428func (c *Context) PUNPCKLLQ(mx, x operand.Op) { 12429 if inst, err := x86.PUNPCKLLQ(mx, x); err == nil { 12430 c.Instruction(inst) 12431 } else { 12432 c.adderror(err) 12433 } 12434} 12435 12436// PUNPCKLLQ: Unpack and Interleave Low-Order Doublewords into Quadwords. 12437// 12438// Forms: 12439// 12440// PUNPCKLLQ xmm xmm 12441// PUNPCKLLQ m128 xmm 12442// Construct and append a PUNPCKLLQ instruction to the active function. 12443// Operates on the global context. 12444func PUNPCKLLQ(mx, x operand.Op) { ctx.PUNPCKLLQ(mx, x) } 12445 12446// PUNPCKLQDQ: Unpack and Interleave Low-Order Quadwords into Double Quadwords. 12447// 12448// Forms: 12449// 12450// PUNPCKLQDQ xmm xmm 12451// PUNPCKLQDQ m128 xmm 12452// Construct and append a PUNPCKLQDQ instruction to the active function. 12453func (c *Context) PUNPCKLQDQ(mx, x operand.Op) { 12454 if inst, err := x86.PUNPCKLQDQ(mx, x); err == nil { 12455 c.Instruction(inst) 12456 } else { 12457 c.adderror(err) 12458 } 12459} 12460 12461// PUNPCKLQDQ: Unpack and Interleave Low-Order Quadwords into Double Quadwords. 12462// 12463// Forms: 12464// 12465// PUNPCKLQDQ xmm xmm 12466// PUNPCKLQDQ m128 xmm 12467// Construct and append a PUNPCKLQDQ instruction to the active function. 12468// Operates on the global context. 12469func PUNPCKLQDQ(mx, x operand.Op) { ctx.PUNPCKLQDQ(mx, x) } 12470 12471// PUNPCKLWL: Unpack and Interleave Low-Order Words into Doublewords. 12472// 12473// Forms: 12474// 12475// PUNPCKLWL xmm xmm 12476// PUNPCKLWL m128 xmm 12477// Construct and append a PUNPCKLWL instruction to the active function. 12478func (c *Context) PUNPCKLWL(mx, x operand.Op) { 12479 if inst, err := x86.PUNPCKLWL(mx, x); err == nil { 12480 c.Instruction(inst) 12481 } else { 12482 c.adderror(err) 12483 } 12484} 12485 12486// PUNPCKLWL: Unpack and Interleave Low-Order Words into Doublewords. 12487// 12488// Forms: 12489// 12490// PUNPCKLWL xmm xmm 12491// PUNPCKLWL m128 xmm 12492// Construct and append a PUNPCKLWL instruction to the active function. 12493// Operates on the global context. 12494func PUNPCKLWL(mx, x operand.Op) { ctx.PUNPCKLWL(mx, x) } 12495 12496// PUSHQ: Push Value Onto the Stack. 12497// 12498// Forms: 12499// 12500// PUSHQ imm8 12501// PUSHQ imm32 12502// PUSHQ r64 12503// PUSHQ m64 12504// Construct and append a PUSHQ instruction to the active function. 12505func (c *Context) PUSHQ(imr operand.Op) { 12506 if inst, err := x86.PUSHQ(imr); err == nil { 12507 c.Instruction(inst) 12508 } else { 12509 c.adderror(err) 12510 } 12511} 12512 12513// PUSHQ: Push Value Onto the Stack. 12514// 12515// Forms: 12516// 12517// PUSHQ imm8 12518// PUSHQ imm32 12519// PUSHQ r64 12520// PUSHQ m64 12521// Construct and append a PUSHQ instruction to the active function. 12522// Operates on the global context. 12523func PUSHQ(imr operand.Op) { ctx.PUSHQ(imr) } 12524 12525// PUSHW: Push Value Onto the Stack. 12526// 12527// Forms: 12528// 12529// PUSHW r16 12530// PUSHW m16 12531// Construct and append a PUSHW instruction to the active function. 12532func (c *Context) PUSHW(mr operand.Op) { 12533 if inst, err := x86.PUSHW(mr); err == nil { 12534 c.Instruction(inst) 12535 } else { 12536 c.adderror(err) 12537 } 12538} 12539 12540// PUSHW: Push Value Onto the Stack. 12541// 12542// Forms: 12543// 12544// PUSHW r16 12545// PUSHW m16 12546// Construct and append a PUSHW instruction to the active function. 12547// Operates on the global context. 12548func PUSHW(mr operand.Op) { ctx.PUSHW(mr) } 12549 12550// PXOR: Packed Bitwise Logical Exclusive OR. 12551// 12552// Forms: 12553// 12554// PXOR xmm xmm 12555// PXOR m128 xmm 12556// Construct and append a PXOR instruction to the active function. 12557func (c *Context) PXOR(mx, x operand.Op) { 12558 if inst, err := x86.PXOR(mx, x); err == nil { 12559 c.Instruction(inst) 12560 } else { 12561 c.adderror(err) 12562 } 12563} 12564 12565// PXOR: Packed Bitwise Logical Exclusive OR. 12566// 12567// Forms: 12568// 12569// PXOR xmm xmm 12570// PXOR m128 xmm 12571// Construct and append a PXOR instruction to the active function. 12572// Operates on the global context. 12573func PXOR(mx, x operand.Op) { ctx.PXOR(mx, x) } 12574 12575// RCLB: Rotate Left through Carry Flag. 12576// 12577// Forms: 12578// 12579// RCLB 1 r8 12580// RCLB imm8 r8 12581// RCLB cl r8 12582// RCLB 1 m8 12583// RCLB imm8 m8 12584// RCLB cl m8 12585// Construct and append a RCLB instruction to the active function. 12586func (c *Context) RCLB(ci, mr operand.Op) { 12587 if inst, err := x86.RCLB(ci, mr); err == nil { 12588 c.Instruction(inst) 12589 } else { 12590 c.adderror(err) 12591 } 12592} 12593 12594// RCLB: Rotate Left through Carry Flag. 12595// 12596// Forms: 12597// 12598// RCLB 1 r8 12599// RCLB imm8 r8 12600// RCLB cl r8 12601// RCLB 1 m8 12602// RCLB imm8 m8 12603// RCLB cl m8 12604// Construct and append a RCLB instruction to the active function. 12605// Operates on the global context. 12606func RCLB(ci, mr operand.Op) { ctx.RCLB(ci, mr) } 12607 12608// RCLL: Rotate Left through Carry Flag. 12609// 12610// Forms: 12611// 12612// RCLL 1 r32 12613// RCLL imm8 r32 12614// RCLL cl r32 12615// RCLL 1 m32 12616// RCLL imm8 m32 12617// RCLL cl m32 12618// Construct and append a RCLL instruction to the active function. 12619func (c *Context) RCLL(ci, mr operand.Op) { 12620 if inst, err := x86.RCLL(ci, mr); err == nil { 12621 c.Instruction(inst) 12622 } else { 12623 c.adderror(err) 12624 } 12625} 12626 12627// RCLL: Rotate Left through Carry Flag. 12628// 12629// Forms: 12630// 12631// RCLL 1 r32 12632// RCLL imm8 r32 12633// RCLL cl r32 12634// RCLL 1 m32 12635// RCLL imm8 m32 12636// RCLL cl m32 12637// Construct and append a RCLL instruction to the active function. 12638// Operates on the global context. 12639func RCLL(ci, mr operand.Op) { ctx.RCLL(ci, mr) } 12640 12641// RCLQ: Rotate Left through Carry Flag. 12642// 12643// Forms: 12644// 12645// RCLQ 1 r64 12646// RCLQ imm8 r64 12647// RCLQ cl r64 12648// RCLQ 1 m64 12649// RCLQ imm8 m64 12650// RCLQ cl m64 12651// Construct and append a RCLQ instruction to the active function. 12652func (c *Context) RCLQ(ci, mr operand.Op) { 12653 if inst, err := x86.RCLQ(ci, mr); err == nil { 12654 c.Instruction(inst) 12655 } else { 12656 c.adderror(err) 12657 } 12658} 12659 12660// RCLQ: Rotate Left through Carry Flag. 12661// 12662// Forms: 12663// 12664// RCLQ 1 r64 12665// RCLQ imm8 r64 12666// RCLQ cl r64 12667// RCLQ 1 m64 12668// RCLQ imm8 m64 12669// RCLQ cl m64 12670// Construct and append a RCLQ instruction to the active function. 12671// Operates on the global context. 12672func RCLQ(ci, mr operand.Op) { ctx.RCLQ(ci, mr) } 12673 12674// RCLW: Rotate Left through Carry Flag. 12675// 12676// Forms: 12677// 12678// RCLW 1 r16 12679// RCLW imm8 r16 12680// RCLW cl r16 12681// RCLW 1 m16 12682// RCLW imm8 m16 12683// RCLW cl m16 12684// Construct and append a RCLW instruction to the active function. 12685func (c *Context) RCLW(ci, mr operand.Op) { 12686 if inst, err := x86.RCLW(ci, mr); err == nil { 12687 c.Instruction(inst) 12688 } else { 12689 c.adderror(err) 12690 } 12691} 12692 12693// RCLW: Rotate Left through Carry Flag. 12694// 12695// Forms: 12696// 12697// RCLW 1 r16 12698// RCLW imm8 r16 12699// RCLW cl r16 12700// RCLW 1 m16 12701// RCLW imm8 m16 12702// RCLW cl m16 12703// Construct and append a RCLW instruction to the active function. 12704// Operates on the global context. 12705func RCLW(ci, mr operand.Op) { ctx.RCLW(ci, mr) } 12706 12707// RCPPS: Compute Approximate Reciprocals of Packed Single-Precision Floating-Point Values. 12708// 12709// Forms: 12710// 12711// RCPPS xmm xmm 12712// RCPPS m128 xmm 12713// Construct and append a RCPPS instruction to the active function. 12714func (c *Context) RCPPS(mx, x operand.Op) { 12715 if inst, err := x86.RCPPS(mx, x); err == nil { 12716 c.Instruction(inst) 12717 } else { 12718 c.adderror(err) 12719 } 12720} 12721 12722// RCPPS: Compute Approximate Reciprocals of Packed Single-Precision Floating-Point Values. 12723// 12724// Forms: 12725// 12726// RCPPS xmm xmm 12727// RCPPS m128 xmm 12728// Construct and append a RCPPS instruction to the active function. 12729// Operates on the global context. 12730func RCPPS(mx, x operand.Op) { ctx.RCPPS(mx, x) } 12731 12732// RCPSS: Compute Approximate Reciprocal of Scalar Single-Precision Floating-Point Values. 12733// 12734// Forms: 12735// 12736// RCPSS xmm xmm 12737// RCPSS m32 xmm 12738// Construct and append a RCPSS instruction to the active function. 12739func (c *Context) RCPSS(mx, x operand.Op) { 12740 if inst, err := x86.RCPSS(mx, x); err == nil { 12741 c.Instruction(inst) 12742 } else { 12743 c.adderror(err) 12744 } 12745} 12746 12747// RCPSS: Compute Approximate Reciprocal of Scalar Single-Precision Floating-Point Values. 12748// 12749// Forms: 12750// 12751// RCPSS xmm xmm 12752// RCPSS m32 xmm 12753// Construct and append a RCPSS instruction to the active function. 12754// Operates on the global context. 12755func RCPSS(mx, x operand.Op) { ctx.RCPSS(mx, x) } 12756 12757// RCRB: Rotate Right through Carry Flag. 12758// 12759// Forms: 12760// 12761// RCRB 1 r8 12762// RCRB imm8 r8 12763// RCRB cl r8 12764// RCRB 1 m8 12765// RCRB imm8 m8 12766// RCRB cl m8 12767// Construct and append a RCRB instruction to the active function. 12768func (c *Context) RCRB(ci, mr operand.Op) { 12769 if inst, err := x86.RCRB(ci, mr); err == nil { 12770 c.Instruction(inst) 12771 } else { 12772 c.adderror(err) 12773 } 12774} 12775 12776// RCRB: Rotate Right through Carry Flag. 12777// 12778// Forms: 12779// 12780// RCRB 1 r8 12781// RCRB imm8 r8 12782// RCRB cl r8 12783// RCRB 1 m8 12784// RCRB imm8 m8 12785// RCRB cl m8 12786// Construct and append a RCRB instruction to the active function. 12787// Operates on the global context. 12788func RCRB(ci, mr operand.Op) { ctx.RCRB(ci, mr) } 12789 12790// RCRL: Rotate Right through Carry Flag. 12791// 12792// Forms: 12793// 12794// RCRL 1 r32 12795// RCRL imm8 r32 12796// RCRL cl r32 12797// RCRL 1 m32 12798// RCRL imm8 m32 12799// RCRL cl m32 12800// Construct and append a RCRL instruction to the active function. 12801func (c *Context) RCRL(ci, mr operand.Op) { 12802 if inst, err := x86.RCRL(ci, mr); err == nil { 12803 c.Instruction(inst) 12804 } else { 12805 c.adderror(err) 12806 } 12807} 12808 12809// RCRL: Rotate Right through Carry Flag. 12810// 12811// Forms: 12812// 12813// RCRL 1 r32 12814// RCRL imm8 r32 12815// RCRL cl r32 12816// RCRL 1 m32 12817// RCRL imm8 m32 12818// RCRL cl m32 12819// Construct and append a RCRL instruction to the active function. 12820// Operates on the global context. 12821func RCRL(ci, mr operand.Op) { ctx.RCRL(ci, mr) } 12822 12823// RCRQ: Rotate Right through Carry Flag. 12824// 12825// Forms: 12826// 12827// RCRQ 1 r64 12828// RCRQ imm8 r64 12829// RCRQ cl r64 12830// RCRQ 1 m64 12831// RCRQ imm8 m64 12832// RCRQ cl m64 12833// Construct and append a RCRQ instruction to the active function. 12834func (c *Context) RCRQ(ci, mr operand.Op) { 12835 if inst, err := x86.RCRQ(ci, mr); err == nil { 12836 c.Instruction(inst) 12837 } else { 12838 c.adderror(err) 12839 } 12840} 12841 12842// RCRQ: Rotate Right through Carry Flag. 12843// 12844// Forms: 12845// 12846// RCRQ 1 r64 12847// RCRQ imm8 r64 12848// RCRQ cl r64 12849// RCRQ 1 m64 12850// RCRQ imm8 m64 12851// RCRQ cl m64 12852// Construct and append a RCRQ instruction to the active function. 12853// Operates on the global context. 12854func RCRQ(ci, mr operand.Op) { ctx.RCRQ(ci, mr) } 12855 12856// RCRW: Rotate Right through Carry Flag. 12857// 12858// Forms: 12859// 12860// RCRW 1 r16 12861// RCRW imm8 r16 12862// RCRW cl r16 12863// RCRW 1 m16 12864// RCRW imm8 m16 12865// RCRW cl m16 12866// Construct and append a RCRW instruction to the active function. 12867func (c *Context) RCRW(ci, mr operand.Op) { 12868 if inst, err := x86.RCRW(ci, mr); err == nil { 12869 c.Instruction(inst) 12870 } else { 12871 c.adderror(err) 12872 } 12873} 12874 12875// RCRW: Rotate Right through Carry Flag. 12876// 12877// Forms: 12878// 12879// RCRW 1 r16 12880// RCRW imm8 r16 12881// RCRW cl r16 12882// RCRW 1 m16 12883// RCRW imm8 m16 12884// RCRW cl m16 12885// Construct and append a RCRW instruction to the active function. 12886// Operates on the global context. 12887func RCRW(ci, mr operand.Op) { ctx.RCRW(ci, mr) } 12888 12889// RDRANDL: Read Random Number. 12890// 12891// Forms: 12892// 12893// RDRANDL r32 12894// Construct and append a RDRANDL instruction to the active function. 12895func (c *Context) RDRANDL(r operand.Op) { 12896 if inst, err := x86.RDRANDL(r); err == nil { 12897 c.Instruction(inst) 12898 } else { 12899 c.adderror(err) 12900 } 12901} 12902 12903// RDRANDL: Read Random Number. 12904// 12905// Forms: 12906// 12907// RDRANDL r32 12908// Construct and append a RDRANDL instruction to the active function. 12909// Operates on the global context. 12910func RDRANDL(r operand.Op) { ctx.RDRANDL(r) } 12911 12912// RDRANDQ: Read Random Number. 12913// 12914// Forms: 12915// 12916// RDRANDQ r64 12917// Construct and append a RDRANDQ instruction to the active function. 12918func (c *Context) RDRANDQ(r operand.Op) { 12919 if inst, err := x86.RDRANDQ(r); err == nil { 12920 c.Instruction(inst) 12921 } else { 12922 c.adderror(err) 12923 } 12924} 12925 12926// RDRANDQ: Read Random Number. 12927// 12928// Forms: 12929// 12930// RDRANDQ r64 12931// Construct and append a RDRANDQ instruction to the active function. 12932// Operates on the global context. 12933func RDRANDQ(r operand.Op) { ctx.RDRANDQ(r) } 12934 12935// RDRANDW: Read Random Number. 12936// 12937// Forms: 12938// 12939// RDRANDW r16 12940// Construct and append a RDRANDW instruction to the active function. 12941func (c *Context) RDRANDW(r operand.Op) { 12942 if inst, err := x86.RDRANDW(r); err == nil { 12943 c.Instruction(inst) 12944 } else { 12945 c.adderror(err) 12946 } 12947} 12948 12949// RDRANDW: Read Random Number. 12950// 12951// Forms: 12952// 12953// RDRANDW r16 12954// Construct and append a RDRANDW instruction to the active function. 12955// Operates on the global context. 12956func RDRANDW(r operand.Op) { ctx.RDRANDW(r) } 12957 12958// RDSEEDL: Read Random SEED. 12959// 12960// Forms: 12961// 12962// RDSEEDL r32 12963// Construct and append a RDSEEDL instruction to the active function. 12964func (c *Context) RDSEEDL(r operand.Op) { 12965 if inst, err := x86.RDSEEDL(r); err == nil { 12966 c.Instruction(inst) 12967 } else { 12968 c.adderror(err) 12969 } 12970} 12971 12972// RDSEEDL: Read Random SEED. 12973// 12974// Forms: 12975// 12976// RDSEEDL r32 12977// Construct and append a RDSEEDL instruction to the active function. 12978// Operates on the global context. 12979func RDSEEDL(r operand.Op) { ctx.RDSEEDL(r) } 12980 12981// RDSEEDQ: Read Random SEED. 12982// 12983// Forms: 12984// 12985// RDSEEDQ r64 12986// Construct and append a RDSEEDQ instruction to the active function. 12987func (c *Context) RDSEEDQ(r operand.Op) { 12988 if inst, err := x86.RDSEEDQ(r); err == nil { 12989 c.Instruction(inst) 12990 } else { 12991 c.adderror(err) 12992 } 12993} 12994 12995// RDSEEDQ: Read Random SEED. 12996// 12997// Forms: 12998// 12999// RDSEEDQ r64 13000// Construct and append a RDSEEDQ instruction to the active function. 13001// Operates on the global context. 13002func RDSEEDQ(r operand.Op) { ctx.RDSEEDQ(r) } 13003 13004// RDSEEDW: Read Random SEED. 13005// 13006// Forms: 13007// 13008// RDSEEDW r16 13009// Construct and append a RDSEEDW instruction to the active function. 13010func (c *Context) RDSEEDW(r operand.Op) { 13011 if inst, err := x86.RDSEEDW(r); err == nil { 13012 c.Instruction(inst) 13013 } else { 13014 c.adderror(err) 13015 } 13016} 13017 13018// RDSEEDW: Read Random SEED. 13019// 13020// Forms: 13021// 13022// RDSEEDW r16 13023// Construct and append a RDSEEDW instruction to the active function. 13024// Operates on the global context. 13025func RDSEEDW(r operand.Op) { ctx.RDSEEDW(r) } 13026 13027// RDTSC: Read Time-Stamp Counter. 13028// 13029// Forms: 13030// 13031// RDTSC 13032// Construct and append a RDTSC instruction to the active function. 13033func (c *Context) RDTSC() { 13034 if inst, err := x86.RDTSC(); err == nil { 13035 c.Instruction(inst) 13036 } else { 13037 c.adderror(err) 13038 } 13039} 13040 13041// RDTSC: Read Time-Stamp Counter. 13042// 13043// Forms: 13044// 13045// RDTSC 13046// Construct and append a RDTSC instruction to the active function. 13047// Operates on the global context. 13048func RDTSC() { ctx.RDTSC() } 13049 13050// RDTSCP: Read Time-Stamp Counter and Processor ID. 13051// 13052// Forms: 13053// 13054// RDTSCP 13055// Construct and append a RDTSCP instruction to the active function. 13056func (c *Context) RDTSCP() { 13057 if inst, err := x86.RDTSCP(); err == nil { 13058 c.Instruction(inst) 13059 } else { 13060 c.adderror(err) 13061 } 13062} 13063 13064// RDTSCP: Read Time-Stamp Counter and Processor ID. 13065// 13066// Forms: 13067// 13068// RDTSCP 13069// Construct and append a RDTSCP instruction to the active function. 13070// Operates on the global context. 13071func RDTSCP() { ctx.RDTSCP() } 13072 13073// RET: Return from Procedure. 13074// 13075// Forms: 13076// 13077// RET 13078// Construct and append a RET instruction to the active function. 13079func (c *Context) RET() { 13080 if inst, err := x86.RET(); err == nil { 13081 c.Instruction(inst) 13082 } else { 13083 c.adderror(err) 13084 } 13085} 13086 13087// RET: Return from Procedure. 13088// 13089// Forms: 13090// 13091// RET 13092// Construct and append a RET instruction to the active function. 13093// Operates on the global context. 13094func RET() { ctx.RET() } 13095 13096// RETFL: Return from Procedure. 13097// 13098// Forms: 13099// 13100// RETFL imm16 13101// Construct and append a RETFL instruction to the active function. 13102func (c *Context) RETFL(i operand.Op) { 13103 if inst, err := x86.RETFL(i); err == nil { 13104 c.Instruction(inst) 13105 } else { 13106 c.adderror(err) 13107 } 13108} 13109 13110// RETFL: Return from Procedure. 13111// 13112// Forms: 13113// 13114// RETFL imm16 13115// Construct and append a RETFL instruction to the active function. 13116// Operates on the global context. 13117func RETFL(i operand.Op) { ctx.RETFL(i) } 13118 13119// RETFQ: Return from Procedure. 13120// 13121// Forms: 13122// 13123// RETFQ imm16 13124// Construct and append a RETFQ instruction to the active function. 13125func (c *Context) RETFQ(i operand.Op) { 13126 if inst, err := x86.RETFQ(i); err == nil { 13127 c.Instruction(inst) 13128 } else { 13129 c.adderror(err) 13130 } 13131} 13132 13133// RETFQ: Return from Procedure. 13134// 13135// Forms: 13136// 13137// RETFQ imm16 13138// Construct and append a RETFQ instruction to the active function. 13139// Operates on the global context. 13140func RETFQ(i operand.Op) { ctx.RETFQ(i) } 13141 13142// RETFW: Return from Procedure. 13143// 13144// Forms: 13145// 13146// RETFW imm16 13147// Construct and append a RETFW instruction to the active function. 13148func (c *Context) RETFW(i operand.Op) { 13149 if inst, err := x86.RETFW(i); err == nil { 13150 c.Instruction(inst) 13151 } else { 13152 c.adderror(err) 13153 } 13154} 13155 13156// RETFW: Return from Procedure. 13157// 13158// Forms: 13159// 13160// RETFW imm16 13161// Construct and append a RETFW instruction to the active function. 13162// Operates on the global context. 13163func RETFW(i operand.Op) { ctx.RETFW(i) } 13164 13165// ROLB: Rotate Left. 13166// 13167// Forms: 13168// 13169// ROLB 1 r8 13170// ROLB imm8 r8 13171// ROLB cl r8 13172// ROLB 1 m8 13173// ROLB imm8 m8 13174// ROLB cl m8 13175// Construct and append a ROLB instruction to the active function. 13176func (c *Context) ROLB(ci, mr operand.Op) { 13177 if inst, err := x86.ROLB(ci, mr); err == nil { 13178 c.Instruction(inst) 13179 } else { 13180 c.adderror(err) 13181 } 13182} 13183 13184// ROLB: Rotate Left. 13185// 13186// Forms: 13187// 13188// ROLB 1 r8 13189// ROLB imm8 r8 13190// ROLB cl r8 13191// ROLB 1 m8 13192// ROLB imm8 m8 13193// ROLB cl m8 13194// Construct and append a ROLB instruction to the active function. 13195// Operates on the global context. 13196func ROLB(ci, mr operand.Op) { ctx.ROLB(ci, mr) } 13197 13198// ROLL: Rotate Left. 13199// 13200// Forms: 13201// 13202// ROLL 1 r32 13203// ROLL imm8 r32 13204// ROLL cl r32 13205// ROLL 1 m32 13206// ROLL imm8 m32 13207// ROLL cl m32 13208// Construct and append a ROLL instruction to the active function. 13209func (c *Context) ROLL(ci, mr operand.Op) { 13210 if inst, err := x86.ROLL(ci, mr); err == nil { 13211 c.Instruction(inst) 13212 } else { 13213 c.adderror(err) 13214 } 13215} 13216 13217// ROLL: Rotate Left. 13218// 13219// Forms: 13220// 13221// ROLL 1 r32 13222// ROLL imm8 r32 13223// ROLL cl r32 13224// ROLL 1 m32 13225// ROLL imm8 m32 13226// ROLL cl m32 13227// Construct and append a ROLL instruction to the active function. 13228// Operates on the global context. 13229func ROLL(ci, mr operand.Op) { ctx.ROLL(ci, mr) } 13230 13231// ROLQ: Rotate Left. 13232// 13233// Forms: 13234// 13235// ROLQ 1 r64 13236// ROLQ imm8 r64 13237// ROLQ cl r64 13238// ROLQ 1 m64 13239// ROLQ imm8 m64 13240// ROLQ cl m64 13241// Construct and append a ROLQ instruction to the active function. 13242func (c *Context) ROLQ(ci, mr operand.Op) { 13243 if inst, err := x86.ROLQ(ci, mr); err == nil { 13244 c.Instruction(inst) 13245 } else { 13246 c.adderror(err) 13247 } 13248} 13249 13250// ROLQ: Rotate Left. 13251// 13252// Forms: 13253// 13254// ROLQ 1 r64 13255// ROLQ imm8 r64 13256// ROLQ cl r64 13257// ROLQ 1 m64 13258// ROLQ imm8 m64 13259// ROLQ cl m64 13260// Construct and append a ROLQ instruction to the active function. 13261// Operates on the global context. 13262func ROLQ(ci, mr operand.Op) { ctx.ROLQ(ci, mr) } 13263 13264// ROLW: Rotate Left. 13265// 13266// Forms: 13267// 13268// ROLW 1 r16 13269// ROLW imm8 r16 13270// ROLW cl r16 13271// ROLW 1 m16 13272// ROLW imm8 m16 13273// ROLW cl m16 13274// Construct and append a ROLW instruction to the active function. 13275func (c *Context) ROLW(ci, mr operand.Op) { 13276 if inst, err := x86.ROLW(ci, mr); err == nil { 13277 c.Instruction(inst) 13278 } else { 13279 c.adderror(err) 13280 } 13281} 13282 13283// ROLW: Rotate Left. 13284// 13285// Forms: 13286// 13287// ROLW 1 r16 13288// ROLW imm8 r16 13289// ROLW cl r16 13290// ROLW 1 m16 13291// ROLW imm8 m16 13292// ROLW cl m16 13293// Construct and append a ROLW instruction to the active function. 13294// Operates on the global context. 13295func ROLW(ci, mr operand.Op) { ctx.ROLW(ci, mr) } 13296 13297// RORB: Rotate Right. 13298// 13299// Forms: 13300// 13301// RORB 1 r8 13302// RORB imm8 r8 13303// RORB cl r8 13304// RORB 1 m8 13305// RORB imm8 m8 13306// RORB cl m8 13307// Construct and append a RORB instruction to the active function. 13308func (c *Context) RORB(ci, mr operand.Op) { 13309 if inst, err := x86.RORB(ci, mr); err == nil { 13310 c.Instruction(inst) 13311 } else { 13312 c.adderror(err) 13313 } 13314} 13315 13316// RORB: Rotate Right. 13317// 13318// Forms: 13319// 13320// RORB 1 r8 13321// RORB imm8 r8 13322// RORB cl r8 13323// RORB 1 m8 13324// RORB imm8 m8 13325// RORB cl m8 13326// Construct and append a RORB instruction to the active function. 13327// Operates on the global context. 13328func RORB(ci, mr operand.Op) { ctx.RORB(ci, mr) } 13329 13330// RORL: Rotate Right. 13331// 13332// Forms: 13333// 13334// RORL 1 r32 13335// RORL imm8 r32 13336// RORL cl r32 13337// RORL 1 m32 13338// RORL imm8 m32 13339// RORL cl m32 13340// Construct and append a RORL instruction to the active function. 13341func (c *Context) RORL(ci, mr operand.Op) { 13342 if inst, err := x86.RORL(ci, mr); err == nil { 13343 c.Instruction(inst) 13344 } else { 13345 c.adderror(err) 13346 } 13347} 13348 13349// RORL: Rotate Right. 13350// 13351// Forms: 13352// 13353// RORL 1 r32 13354// RORL imm8 r32 13355// RORL cl r32 13356// RORL 1 m32 13357// RORL imm8 m32 13358// RORL cl m32 13359// Construct and append a RORL instruction to the active function. 13360// Operates on the global context. 13361func RORL(ci, mr operand.Op) { ctx.RORL(ci, mr) } 13362 13363// RORQ: Rotate Right. 13364// 13365// Forms: 13366// 13367// RORQ 1 r64 13368// RORQ imm8 r64 13369// RORQ cl r64 13370// RORQ 1 m64 13371// RORQ imm8 m64 13372// RORQ cl m64 13373// Construct and append a RORQ instruction to the active function. 13374func (c *Context) RORQ(ci, mr operand.Op) { 13375 if inst, err := x86.RORQ(ci, mr); err == nil { 13376 c.Instruction(inst) 13377 } else { 13378 c.adderror(err) 13379 } 13380} 13381 13382// RORQ: Rotate Right. 13383// 13384// Forms: 13385// 13386// RORQ 1 r64 13387// RORQ imm8 r64 13388// RORQ cl r64 13389// RORQ 1 m64 13390// RORQ imm8 m64 13391// RORQ cl m64 13392// Construct and append a RORQ instruction to the active function. 13393// Operates on the global context. 13394func RORQ(ci, mr operand.Op) { ctx.RORQ(ci, mr) } 13395 13396// RORW: Rotate Right. 13397// 13398// Forms: 13399// 13400// RORW 1 r16 13401// RORW imm8 r16 13402// RORW cl r16 13403// RORW 1 m16 13404// RORW imm8 m16 13405// RORW cl m16 13406// Construct and append a RORW instruction to the active function. 13407func (c *Context) RORW(ci, mr operand.Op) { 13408 if inst, err := x86.RORW(ci, mr); err == nil { 13409 c.Instruction(inst) 13410 } else { 13411 c.adderror(err) 13412 } 13413} 13414 13415// RORW: Rotate Right. 13416// 13417// Forms: 13418// 13419// RORW 1 r16 13420// RORW imm8 r16 13421// RORW cl r16 13422// RORW 1 m16 13423// RORW imm8 m16 13424// RORW cl m16 13425// Construct and append a RORW instruction to the active function. 13426// Operates on the global context. 13427func RORW(ci, mr operand.Op) { ctx.RORW(ci, mr) } 13428 13429// RORXL: Rotate Right Logical Without Affecting Flags. 13430// 13431// Forms: 13432// 13433// RORXL imm8 r32 r32 13434// RORXL imm8 m32 r32 13435// Construct and append a RORXL instruction to the active function. 13436func (c *Context) RORXL(i, mr, r operand.Op) { 13437 if inst, err := x86.RORXL(i, mr, r); err == nil { 13438 c.Instruction(inst) 13439 } else { 13440 c.adderror(err) 13441 } 13442} 13443 13444// RORXL: Rotate Right Logical Without Affecting Flags. 13445// 13446// Forms: 13447// 13448// RORXL imm8 r32 r32 13449// RORXL imm8 m32 r32 13450// Construct and append a RORXL instruction to the active function. 13451// Operates on the global context. 13452func RORXL(i, mr, r operand.Op) { ctx.RORXL(i, mr, r) } 13453 13454// RORXQ: Rotate Right Logical Without Affecting Flags. 13455// 13456// Forms: 13457// 13458// RORXQ imm8 r64 r64 13459// RORXQ imm8 m64 r64 13460// Construct and append a RORXQ instruction to the active function. 13461func (c *Context) RORXQ(i, mr, r operand.Op) { 13462 if inst, err := x86.RORXQ(i, mr, r); err == nil { 13463 c.Instruction(inst) 13464 } else { 13465 c.adderror(err) 13466 } 13467} 13468 13469// RORXQ: Rotate Right Logical Without Affecting Flags. 13470// 13471// Forms: 13472// 13473// RORXQ imm8 r64 r64 13474// RORXQ imm8 m64 r64 13475// Construct and append a RORXQ instruction to the active function. 13476// Operates on the global context. 13477func RORXQ(i, mr, r operand.Op) { ctx.RORXQ(i, mr, r) } 13478 13479// ROUNDPD: Round Packed Double Precision Floating-Point Values. 13480// 13481// Forms: 13482// 13483// ROUNDPD imm8 xmm xmm 13484// ROUNDPD imm8 m128 xmm 13485// Construct and append a ROUNDPD instruction to the active function. 13486func (c *Context) ROUNDPD(i, mx, x operand.Op) { 13487 if inst, err := x86.ROUNDPD(i, mx, x); err == nil { 13488 c.Instruction(inst) 13489 } else { 13490 c.adderror(err) 13491 } 13492} 13493 13494// ROUNDPD: Round Packed Double Precision Floating-Point Values. 13495// 13496// Forms: 13497// 13498// ROUNDPD imm8 xmm xmm 13499// ROUNDPD imm8 m128 xmm 13500// Construct and append a ROUNDPD instruction to the active function. 13501// Operates on the global context. 13502func ROUNDPD(i, mx, x operand.Op) { ctx.ROUNDPD(i, mx, x) } 13503 13504// ROUNDPS: Round Packed Single Precision Floating-Point Values. 13505// 13506// Forms: 13507// 13508// ROUNDPS imm8 xmm xmm 13509// ROUNDPS imm8 m128 xmm 13510// Construct and append a ROUNDPS instruction to the active function. 13511func (c *Context) ROUNDPS(i, mx, x operand.Op) { 13512 if inst, err := x86.ROUNDPS(i, mx, x); err == nil { 13513 c.Instruction(inst) 13514 } else { 13515 c.adderror(err) 13516 } 13517} 13518 13519// ROUNDPS: Round Packed Single Precision Floating-Point Values. 13520// 13521// Forms: 13522// 13523// ROUNDPS imm8 xmm xmm 13524// ROUNDPS imm8 m128 xmm 13525// Construct and append a ROUNDPS instruction to the active function. 13526// Operates on the global context. 13527func ROUNDPS(i, mx, x operand.Op) { ctx.ROUNDPS(i, mx, x) } 13528 13529// ROUNDSD: Round Scalar Double Precision Floating-Point Values. 13530// 13531// Forms: 13532// 13533// ROUNDSD imm8 xmm xmm 13534// ROUNDSD imm8 m64 xmm 13535// Construct and append a ROUNDSD instruction to the active function. 13536func (c *Context) ROUNDSD(i, mx, x operand.Op) { 13537 if inst, err := x86.ROUNDSD(i, mx, x); err == nil { 13538 c.Instruction(inst) 13539 } else { 13540 c.adderror(err) 13541 } 13542} 13543 13544// ROUNDSD: Round Scalar Double Precision Floating-Point Values. 13545// 13546// Forms: 13547// 13548// ROUNDSD imm8 xmm xmm 13549// ROUNDSD imm8 m64 xmm 13550// Construct and append a ROUNDSD instruction to the active function. 13551// Operates on the global context. 13552func ROUNDSD(i, mx, x operand.Op) { ctx.ROUNDSD(i, mx, x) } 13553 13554// ROUNDSS: Round Scalar Single Precision Floating-Point Values. 13555// 13556// Forms: 13557// 13558// ROUNDSS imm8 xmm xmm 13559// ROUNDSS imm8 m32 xmm 13560// Construct and append a ROUNDSS instruction to the active function. 13561func (c *Context) ROUNDSS(i, mx, x operand.Op) { 13562 if inst, err := x86.ROUNDSS(i, mx, x); err == nil { 13563 c.Instruction(inst) 13564 } else { 13565 c.adderror(err) 13566 } 13567} 13568 13569// ROUNDSS: Round Scalar Single Precision Floating-Point Values. 13570// 13571// Forms: 13572// 13573// ROUNDSS imm8 xmm xmm 13574// ROUNDSS imm8 m32 xmm 13575// Construct and append a ROUNDSS instruction to the active function. 13576// Operates on the global context. 13577func ROUNDSS(i, mx, x operand.Op) { ctx.ROUNDSS(i, mx, x) } 13578 13579// RSQRTPS: Compute Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values. 13580// 13581// Forms: 13582// 13583// RSQRTPS xmm xmm 13584// RSQRTPS m128 xmm 13585// Construct and append a RSQRTPS instruction to the active function. 13586func (c *Context) RSQRTPS(mx, x operand.Op) { 13587 if inst, err := x86.RSQRTPS(mx, x); err == nil { 13588 c.Instruction(inst) 13589 } else { 13590 c.adderror(err) 13591 } 13592} 13593 13594// RSQRTPS: Compute Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values. 13595// 13596// Forms: 13597// 13598// RSQRTPS xmm xmm 13599// RSQRTPS m128 xmm 13600// Construct and append a RSQRTPS instruction to the active function. 13601// Operates on the global context. 13602func RSQRTPS(mx, x operand.Op) { ctx.RSQRTPS(mx, x) } 13603 13604// RSQRTSS: Compute Reciprocal of Square Root of Scalar Single-Precision Floating-Point Value. 13605// 13606// Forms: 13607// 13608// RSQRTSS xmm xmm 13609// RSQRTSS m32 xmm 13610// Construct and append a RSQRTSS instruction to the active function. 13611func (c *Context) RSQRTSS(mx, x operand.Op) { 13612 if inst, err := x86.RSQRTSS(mx, x); err == nil { 13613 c.Instruction(inst) 13614 } else { 13615 c.adderror(err) 13616 } 13617} 13618 13619// RSQRTSS: Compute Reciprocal of Square Root of Scalar Single-Precision Floating-Point Value. 13620// 13621// Forms: 13622// 13623// RSQRTSS xmm xmm 13624// RSQRTSS m32 xmm 13625// Construct and append a RSQRTSS instruction to the active function. 13626// Operates on the global context. 13627func RSQRTSS(mx, x operand.Op) { ctx.RSQRTSS(mx, x) } 13628 13629// SALB: Arithmetic Shift Left. 13630// 13631// Forms: 13632// 13633// SALB 1 r8 13634// SALB imm8 r8 13635// SALB cl r8 13636// SALB 1 m8 13637// SALB imm8 m8 13638// SALB cl m8 13639// Construct and append a SALB instruction to the active function. 13640func (c *Context) SALB(ci, mr operand.Op) { 13641 if inst, err := x86.SALB(ci, mr); err == nil { 13642 c.Instruction(inst) 13643 } else { 13644 c.adderror(err) 13645 } 13646} 13647 13648// SALB: Arithmetic Shift Left. 13649// 13650// Forms: 13651// 13652// SALB 1 r8 13653// SALB imm8 r8 13654// SALB cl r8 13655// SALB 1 m8 13656// SALB imm8 m8 13657// SALB cl m8 13658// Construct and append a SALB instruction to the active function. 13659// Operates on the global context. 13660func SALB(ci, mr operand.Op) { ctx.SALB(ci, mr) } 13661 13662// SALL: Arithmetic Shift Left. 13663// 13664// Forms: 13665// 13666// SALL 1 r32 13667// SALL imm8 r32 13668// SALL cl r32 13669// SALL 1 m32 13670// SALL imm8 m32 13671// SALL cl m32 13672// Construct and append a SALL instruction to the active function. 13673func (c *Context) SALL(ci, mr operand.Op) { 13674 if inst, err := x86.SALL(ci, mr); err == nil { 13675 c.Instruction(inst) 13676 } else { 13677 c.adderror(err) 13678 } 13679} 13680 13681// SALL: Arithmetic Shift Left. 13682// 13683// Forms: 13684// 13685// SALL 1 r32 13686// SALL imm8 r32 13687// SALL cl r32 13688// SALL 1 m32 13689// SALL imm8 m32 13690// SALL cl m32 13691// Construct and append a SALL instruction to the active function. 13692// Operates on the global context. 13693func SALL(ci, mr operand.Op) { ctx.SALL(ci, mr) } 13694 13695// SALQ: Arithmetic Shift Left. 13696// 13697// Forms: 13698// 13699// SALQ 1 r64 13700// SALQ imm8 r64 13701// SALQ cl r64 13702// SALQ 1 m64 13703// SALQ imm8 m64 13704// SALQ cl m64 13705// Construct and append a SALQ instruction to the active function. 13706func (c *Context) SALQ(ci, mr operand.Op) { 13707 if inst, err := x86.SALQ(ci, mr); err == nil { 13708 c.Instruction(inst) 13709 } else { 13710 c.adderror(err) 13711 } 13712} 13713 13714// SALQ: Arithmetic Shift Left. 13715// 13716// Forms: 13717// 13718// SALQ 1 r64 13719// SALQ imm8 r64 13720// SALQ cl r64 13721// SALQ 1 m64 13722// SALQ imm8 m64 13723// SALQ cl m64 13724// Construct and append a SALQ instruction to the active function. 13725// Operates on the global context. 13726func SALQ(ci, mr operand.Op) { ctx.SALQ(ci, mr) } 13727 13728// SALW: Arithmetic Shift Left. 13729// 13730// Forms: 13731// 13732// SALW 1 r16 13733// SALW imm8 r16 13734// SALW cl r16 13735// SALW 1 m16 13736// SALW imm8 m16 13737// SALW cl m16 13738// Construct and append a SALW instruction to the active function. 13739func (c *Context) SALW(ci, mr operand.Op) { 13740 if inst, err := x86.SALW(ci, mr); err == nil { 13741 c.Instruction(inst) 13742 } else { 13743 c.adderror(err) 13744 } 13745} 13746 13747// SALW: Arithmetic Shift Left. 13748// 13749// Forms: 13750// 13751// SALW 1 r16 13752// SALW imm8 r16 13753// SALW cl r16 13754// SALW 1 m16 13755// SALW imm8 m16 13756// SALW cl m16 13757// Construct and append a SALW instruction to the active function. 13758// Operates on the global context. 13759func SALW(ci, mr operand.Op) { ctx.SALW(ci, mr) } 13760 13761// SARB: Arithmetic Shift Right. 13762// 13763// Forms: 13764// 13765// SARB 1 r8 13766// SARB imm8 r8 13767// SARB cl r8 13768// SARB 1 m8 13769// SARB imm8 m8 13770// SARB cl m8 13771// Construct and append a SARB instruction to the active function. 13772func (c *Context) SARB(ci, mr operand.Op) { 13773 if inst, err := x86.SARB(ci, mr); err == nil { 13774 c.Instruction(inst) 13775 } else { 13776 c.adderror(err) 13777 } 13778} 13779 13780// SARB: Arithmetic Shift Right. 13781// 13782// Forms: 13783// 13784// SARB 1 r8 13785// SARB imm8 r8 13786// SARB cl r8 13787// SARB 1 m8 13788// SARB imm8 m8 13789// SARB cl m8 13790// Construct and append a SARB instruction to the active function. 13791// Operates on the global context. 13792func SARB(ci, mr operand.Op) { ctx.SARB(ci, mr) } 13793 13794// SARL: Arithmetic Shift Right. 13795// 13796// Forms: 13797// 13798// SARL 1 r32 13799// SARL imm8 r32 13800// SARL cl r32 13801// SARL 1 m32 13802// SARL imm8 m32 13803// SARL cl m32 13804// Construct and append a SARL instruction to the active function. 13805func (c *Context) SARL(ci, mr operand.Op) { 13806 if inst, err := x86.SARL(ci, mr); err == nil { 13807 c.Instruction(inst) 13808 } else { 13809 c.adderror(err) 13810 } 13811} 13812 13813// SARL: Arithmetic Shift Right. 13814// 13815// Forms: 13816// 13817// SARL 1 r32 13818// SARL imm8 r32 13819// SARL cl r32 13820// SARL 1 m32 13821// SARL imm8 m32 13822// SARL cl m32 13823// Construct and append a SARL instruction to the active function. 13824// Operates on the global context. 13825func SARL(ci, mr operand.Op) { ctx.SARL(ci, mr) } 13826 13827// SARQ: Arithmetic Shift Right. 13828// 13829// Forms: 13830// 13831// SARQ 1 r64 13832// SARQ imm8 r64 13833// SARQ cl r64 13834// SARQ 1 m64 13835// SARQ imm8 m64 13836// SARQ cl m64 13837// Construct and append a SARQ instruction to the active function. 13838func (c *Context) SARQ(ci, mr operand.Op) { 13839 if inst, err := x86.SARQ(ci, mr); err == nil { 13840 c.Instruction(inst) 13841 } else { 13842 c.adderror(err) 13843 } 13844} 13845 13846// SARQ: Arithmetic Shift Right. 13847// 13848// Forms: 13849// 13850// SARQ 1 r64 13851// SARQ imm8 r64 13852// SARQ cl r64 13853// SARQ 1 m64 13854// SARQ imm8 m64 13855// SARQ cl m64 13856// Construct and append a SARQ instruction to the active function. 13857// Operates on the global context. 13858func SARQ(ci, mr operand.Op) { ctx.SARQ(ci, mr) } 13859 13860// SARW: Arithmetic Shift Right. 13861// 13862// Forms: 13863// 13864// SARW 1 r16 13865// SARW imm8 r16 13866// SARW cl r16 13867// SARW 1 m16 13868// SARW imm8 m16 13869// SARW cl m16 13870// Construct and append a SARW instruction to the active function. 13871func (c *Context) SARW(ci, mr operand.Op) { 13872 if inst, err := x86.SARW(ci, mr); err == nil { 13873 c.Instruction(inst) 13874 } else { 13875 c.adderror(err) 13876 } 13877} 13878 13879// SARW: Arithmetic Shift Right. 13880// 13881// Forms: 13882// 13883// SARW 1 r16 13884// SARW imm8 r16 13885// SARW cl r16 13886// SARW 1 m16 13887// SARW imm8 m16 13888// SARW cl m16 13889// Construct and append a SARW instruction to the active function. 13890// Operates on the global context. 13891func SARW(ci, mr operand.Op) { ctx.SARW(ci, mr) } 13892 13893// SARXL: Arithmetic Shift Right Without Affecting Flags. 13894// 13895// Forms: 13896// 13897// SARXL r32 r32 r32 13898// SARXL r32 m32 r32 13899// Construct and append a SARXL instruction to the active function. 13900func (c *Context) SARXL(r, mr, r1 operand.Op) { 13901 if inst, err := x86.SARXL(r, mr, r1); err == nil { 13902 c.Instruction(inst) 13903 } else { 13904 c.adderror(err) 13905 } 13906} 13907 13908// SARXL: Arithmetic Shift Right Without Affecting Flags. 13909// 13910// Forms: 13911// 13912// SARXL r32 r32 r32 13913// SARXL r32 m32 r32 13914// Construct and append a SARXL instruction to the active function. 13915// Operates on the global context. 13916func SARXL(r, mr, r1 operand.Op) { ctx.SARXL(r, mr, r1) } 13917 13918// SARXQ: Arithmetic Shift Right Without Affecting Flags. 13919// 13920// Forms: 13921// 13922// SARXQ r64 r64 r64 13923// SARXQ r64 m64 r64 13924// Construct and append a SARXQ instruction to the active function. 13925func (c *Context) SARXQ(r, mr, r1 operand.Op) { 13926 if inst, err := x86.SARXQ(r, mr, r1); err == nil { 13927 c.Instruction(inst) 13928 } else { 13929 c.adderror(err) 13930 } 13931} 13932 13933// SARXQ: Arithmetic Shift Right Without Affecting Flags. 13934// 13935// Forms: 13936// 13937// SARXQ r64 r64 r64 13938// SARXQ r64 m64 r64 13939// Construct and append a SARXQ instruction to the active function. 13940// Operates on the global context. 13941func SARXQ(r, mr, r1 operand.Op) { ctx.SARXQ(r, mr, r1) } 13942 13943// SBBB: Subtract with Borrow. 13944// 13945// Forms: 13946// 13947// SBBB imm8 al 13948// SBBB imm8 r8 13949// SBBB r8 r8 13950// SBBB m8 r8 13951// SBBB imm8 m8 13952// SBBB r8 m8 13953// Construct and append a SBBB instruction to the active function. 13954func (c *Context) SBBB(imr, amr operand.Op) { 13955 if inst, err := x86.SBBB(imr, amr); err == nil { 13956 c.Instruction(inst) 13957 } else { 13958 c.adderror(err) 13959 } 13960} 13961 13962// SBBB: Subtract with Borrow. 13963// 13964// Forms: 13965// 13966// SBBB imm8 al 13967// SBBB imm8 r8 13968// SBBB r8 r8 13969// SBBB m8 r8 13970// SBBB imm8 m8 13971// SBBB r8 m8 13972// Construct and append a SBBB instruction to the active function. 13973// Operates on the global context. 13974func SBBB(imr, amr operand.Op) { ctx.SBBB(imr, amr) } 13975 13976// SBBL: Subtract with Borrow. 13977// 13978// Forms: 13979// 13980// SBBL imm32 eax 13981// SBBL imm8 r32 13982// SBBL imm32 r32 13983// SBBL r32 r32 13984// SBBL m32 r32 13985// SBBL imm8 m32 13986// SBBL imm32 m32 13987// SBBL r32 m32 13988// Construct and append a SBBL instruction to the active function. 13989func (c *Context) SBBL(imr, emr operand.Op) { 13990 if inst, err := x86.SBBL(imr, emr); err == nil { 13991 c.Instruction(inst) 13992 } else { 13993 c.adderror(err) 13994 } 13995} 13996 13997// SBBL: Subtract with Borrow. 13998// 13999// Forms: 14000// 14001// SBBL imm32 eax 14002// SBBL imm8 r32 14003// SBBL imm32 r32 14004// SBBL r32 r32 14005// SBBL m32 r32 14006// SBBL imm8 m32 14007// SBBL imm32 m32 14008// SBBL r32 m32 14009// Construct and append a SBBL instruction to the active function. 14010// Operates on the global context. 14011func SBBL(imr, emr operand.Op) { ctx.SBBL(imr, emr) } 14012 14013// SBBQ: Subtract with Borrow. 14014// 14015// Forms: 14016// 14017// SBBQ imm32 rax 14018// SBBQ imm8 r64 14019// SBBQ imm32 r64 14020// SBBQ r64 r64 14021// SBBQ m64 r64 14022// SBBQ imm8 m64 14023// SBBQ imm32 m64 14024// SBBQ r64 m64 14025// Construct and append a SBBQ instruction to the active function. 14026func (c *Context) SBBQ(imr, mr operand.Op) { 14027 if inst, err := x86.SBBQ(imr, mr); err == nil { 14028 c.Instruction(inst) 14029 } else { 14030 c.adderror(err) 14031 } 14032} 14033 14034// SBBQ: Subtract with Borrow. 14035// 14036// Forms: 14037// 14038// SBBQ imm32 rax 14039// SBBQ imm8 r64 14040// SBBQ imm32 r64 14041// SBBQ r64 r64 14042// SBBQ m64 r64 14043// SBBQ imm8 m64 14044// SBBQ imm32 m64 14045// SBBQ r64 m64 14046// Construct and append a SBBQ instruction to the active function. 14047// Operates on the global context. 14048func SBBQ(imr, mr operand.Op) { ctx.SBBQ(imr, mr) } 14049 14050// SBBW: Subtract with Borrow. 14051// 14052// Forms: 14053// 14054// SBBW imm16 ax 14055// SBBW imm8 r16 14056// SBBW imm16 r16 14057// SBBW r16 r16 14058// SBBW m16 r16 14059// SBBW imm8 m16 14060// SBBW imm16 m16 14061// SBBW r16 m16 14062// Construct and append a SBBW instruction to the active function. 14063func (c *Context) SBBW(imr, amr operand.Op) { 14064 if inst, err := x86.SBBW(imr, amr); err == nil { 14065 c.Instruction(inst) 14066 } else { 14067 c.adderror(err) 14068 } 14069} 14070 14071// SBBW: Subtract with Borrow. 14072// 14073// Forms: 14074// 14075// SBBW imm16 ax 14076// SBBW imm8 r16 14077// SBBW imm16 r16 14078// SBBW r16 r16 14079// SBBW m16 r16 14080// SBBW imm8 m16 14081// SBBW imm16 m16 14082// SBBW r16 m16 14083// Construct and append a SBBW instruction to the active function. 14084// Operates on the global context. 14085func SBBW(imr, amr operand.Op) { ctx.SBBW(imr, amr) } 14086 14087// SETCC: Set byte if above or equal (CF == 0). 14088// 14089// Forms: 14090// 14091// SETCC r8 14092// SETCC m8 14093// Construct and append a SETCC instruction to the active function. 14094func (c *Context) SETCC(mr operand.Op) { 14095 if inst, err := x86.SETCC(mr); err == nil { 14096 c.Instruction(inst) 14097 } else { 14098 c.adderror(err) 14099 } 14100} 14101 14102// SETCC: Set byte if above or equal (CF == 0). 14103// 14104// Forms: 14105// 14106// SETCC r8 14107// SETCC m8 14108// Construct and append a SETCC instruction to the active function. 14109// Operates on the global context. 14110func SETCC(mr operand.Op) { ctx.SETCC(mr) } 14111 14112// SETCS: Set byte if below (CF == 1). 14113// 14114// Forms: 14115// 14116// SETCS r8 14117// SETCS m8 14118// Construct and append a SETCS instruction to the active function. 14119func (c *Context) SETCS(mr operand.Op) { 14120 if inst, err := x86.SETCS(mr); err == nil { 14121 c.Instruction(inst) 14122 } else { 14123 c.adderror(err) 14124 } 14125} 14126 14127// SETCS: Set byte if below (CF == 1). 14128// 14129// Forms: 14130// 14131// SETCS r8 14132// SETCS m8 14133// Construct and append a SETCS instruction to the active function. 14134// Operates on the global context. 14135func SETCS(mr operand.Op) { ctx.SETCS(mr) } 14136 14137// SETEQ: Set byte if equal (ZF == 1). 14138// 14139// Forms: 14140// 14141// SETEQ r8 14142// SETEQ m8 14143// Construct and append a SETEQ instruction to the active function. 14144func (c *Context) SETEQ(mr operand.Op) { 14145 if inst, err := x86.SETEQ(mr); err == nil { 14146 c.Instruction(inst) 14147 } else { 14148 c.adderror(err) 14149 } 14150} 14151 14152// SETEQ: Set byte if equal (ZF == 1). 14153// 14154// Forms: 14155// 14156// SETEQ r8 14157// SETEQ m8 14158// Construct and append a SETEQ instruction to the active function. 14159// Operates on the global context. 14160func SETEQ(mr operand.Op) { ctx.SETEQ(mr) } 14161 14162// SETGE: Set byte if greater or equal (SF == OF). 14163// 14164// Forms: 14165// 14166// SETGE r8 14167// SETGE m8 14168// Construct and append a SETGE instruction to the active function. 14169func (c *Context) SETGE(mr operand.Op) { 14170 if inst, err := x86.SETGE(mr); err == nil { 14171 c.Instruction(inst) 14172 } else { 14173 c.adderror(err) 14174 } 14175} 14176 14177// SETGE: Set byte if greater or equal (SF == OF). 14178// 14179// Forms: 14180// 14181// SETGE r8 14182// SETGE m8 14183// Construct and append a SETGE instruction to the active function. 14184// Operates on the global context. 14185func SETGE(mr operand.Op) { ctx.SETGE(mr) } 14186 14187// SETGT: Set byte if greater (ZF == 0 and SF == OF). 14188// 14189// Forms: 14190// 14191// SETGT r8 14192// SETGT m8 14193// Construct and append a SETGT instruction to the active function. 14194func (c *Context) SETGT(mr operand.Op) { 14195 if inst, err := x86.SETGT(mr); err == nil { 14196 c.Instruction(inst) 14197 } else { 14198 c.adderror(err) 14199 } 14200} 14201 14202// SETGT: Set byte if greater (ZF == 0 and SF == OF). 14203// 14204// Forms: 14205// 14206// SETGT r8 14207// SETGT m8 14208// Construct and append a SETGT instruction to the active function. 14209// Operates on the global context. 14210func SETGT(mr operand.Op) { ctx.SETGT(mr) } 14211 14212// SETHI: Set byte if above (CF == 0 and ZF == 0). 14213// 14214// Forms: 14215// 14216// SETHI r8 14217// SETHI m8 14218// Construct and append a SETHI instruction to the active function. 14219func (c *Context) SETHI(mr operand.Op) { 14220 if inst, err := x86.SETHI(mr); err == nil { 14221 c.Instruction(inst) 14222 } else { 14223 c.adderror(err) 14224 } 14225} 14226 14227// SETHI: Set byte if above (CF == 0 and ZF == 0). 14228// 14229// Forms: 14230// 14231// SETHI r8 14232// SETHI m8 14233// Construct and append a SETHI instruction to the active function. 14234// Operates on the global context. 14235func SETHI(mr operand.Op) { ctx.SETHI(mr) } 14236 14237// SETLE: Set byte if less or equal (ZF == 1 or SF != OF). 14238// 14239// Forms: 14240// 14241// SETLE r8 14242// SETLE m8 14243// Construct and append a SETLE instruction to the active function. 14244func (c *Context) SETLE(mr operand.Op) { 14245 if inst, err := x86.SETLE(mr); err == nil { 14246 c.Instruction(inst) 14247 } else { 14248 c.adderror(err) 14249 } 14250} 14251 14252// SETLE: Set byte if less or equal (ZF == 1 or SF != OF). 14253// 14254// Forms: 14255// 14256// SETLE r8 14257// SETLE m8 14258// Construct and append a SETLE instruction to the active function. 14259// Operates on the global context. 14260func SETLE(mr operand.Op) { ctx.SETLE(mr) } 14261 14262// SETLS: Set byte if below or equal (CF == 1 or ZF == 1). 14263// 14264// Forms: 14265// 14266// SETLS r8 14267// SETLS m8 14268// Construct and append a SETLS instruction to the active function. 14269func (c *Context) SETLS(mr operand.Op) { 14270 if inst, err := x86.SETLS(mr); err == nil { 14271 c.Instruction(inst) 14272 } else { 14273 c.adderror(err) 14274 } 14275} 14276 14277// SETLS: Set byte if below or equal (CF == 1 or ZF == 1). 14278// 14279// Forms: 14280// 14281// SETLS r8 14282// SETLS m8 14283// Construct and append a SETLS instruction to the active function. 14284// Operates on the global context. 14285func SETLS(mr operand.Op) { ctx.SETLS(mr) } 14286 14287// SETLT: Set byte if less (SF != OF). 14288// 14289// Forms: 14290// 14291// SETLT r8 14292// SETLT m8 14293// Construct and append a SETLT instruction to the active function. 14294func (c *Context) SETLT(mr operand.Op) { 14295 if inst, err := x86.SETLT(mr); err == nil { 14296 c.Instruction(inst) 14297 } else { 14298 c.adderror(err) 14299 } 14300} 14301 14302// SETLT: Set byte if less (SF != OF). 14303// 14304// Forms: 14305// 14306// SETLT r8 14307// SETLT m8 14308// Construct and append a SETLT instruction to the active function. 14309// Operates on the global context. 14310func SETLT(mr operand.Op) { ctx.SETLT(mr) } 14311 14312// SETMI: Set byte if sign (SF == 1). 14313// 14314// Forms: 14315// 14316// SETMI r8 14317// SETMI m8 14318// Construct and append a SETMI instruction to the active function. 14319func (c *Context) SETMI(mr operand.Op) { 14320 if inst, err := x86.SETMI(mr); err == nil { 14321 c.Instruction(inst) 14322 } else { 14323 c.adderror(err) 14324 } 14325} 14326 14327// SETMI: Set byte if sign (SF == 1). 14328// 14329// Forms: 14330// 14331// SETMI r8 14332// SETMI m8 14333// Construct and append a SETMI instruction to the active function. 14334// Operates on the global context. 14335func SETMI(mr operand.Op) { ctx.SETMI(mr) } 14336 14337// SETNE: Set byte if not equal (ZF == 0). 14338// 14339// Forms: 14340// 14341// SETNE r8 14342// SETNE m8 14343// Construct and append a SETNE instruction to the active function. 14344func (c *Context) SETNE(mr operand.Op) { 14345 if inst, err := x86.SETNE(mr); err == nil { 14346 c.Instruction(inst) 14347 } else { 14348 c.adderror(err) 14349 } 14350} 14351 14352// SETNE: Set byte if not equal (ZF == 0). 14353// 14354// Forms: 14355// 14356// SETNE r8 14357// SETNE m8 14358// Construct and append a SETNE instruction to the active function. 14359// Operates on the global context. 14360func SETNE(mr operand.Op) { ctx.SETNE(mr) } 14361 14362// SETOC: Set byte if not overflow (OF == 0). 14363// 14364// Forms: 14365// 14366// SETOC r8 14367// SETOC m8 14368// Construct and append a SETOC instruction to the active function. 14369func (c *Context) SETOC(mr operand.Op) { 14370 if inst, err := x86.SETOC(mr); err == nil { 14371 c.Instruction(inst) 14372 } else { 14373 c.adderror(err) 14374 } 14375} 14376 14377// SETOC: Set byte if not overflow (OF == 0). 14378// 14379// Forms: 14380// 14381// SETOC r8 14382// SETOC m8 14383// Construct and append a SETOC instruction to the active function. 14384// Operates on the global context. 14385func SETOC(mr operand.Op) { ctx.SETOC(mr) } 14386 14387// SETOS: Set byte if overflow (OF == 1). 14388// 14389// Forms: 14390// 14391// SETOS r8 14392// SETOS m8 14393// Construct and append a SETOS instruction to the active function. 14394func (c *Context) SETOS(mr operand.Op) { 14395 if inst, err := x86.SETOS(mr); err == nil { 14396 c.Instruction(inst) 14397 } else { 14398 c.adderror(err) 14399 } 14400} 14401 14402// SETOS: Set byte if overflow (OF == 1). 14403// 14404// Forms: 14405// 14406// SETOS r8 14407// SETOS m8 14408// Construct and append a SETOS instruction to the active function. 14409// Operates on the global context. 14410func SETOS(mr operand.Op) { ctx.SETOS(mr) } 14411 14412// SETPC: Set byte if not parity (PF == 0). 14413// 14414// Forms: 14415// 14416// SETPC r8 14417// SETPC m8 14418// Construct and append a SETPC instruction to the active function. 14419func (c *Context) SETPC(mr operand.Op) { 14420 if inst, err := x86.SETPC(mr); err == nil { 14421 c.Instruction(inst) 14422 } else { 14423 c.adderror(err) 14424 } 14425} 14426 14427// SETPC: Set byte if not parity (PF == 0). 14428// 14429// Forms: 14430// 14431// SETPC r8 14432// SETPC m8 14433// Construct and append a SETPC instruction to the active function. 14434// Operates on the global context. 14435func SETPC(mr operand.Op) { ctx.SETPC(mr) } 14436 14437// SETPL: Set byte if not sign (SF == 0). 14438// 14439// Forms: 14440// 14441// SETPL r8 14442// SETPL m8 14443// Construct and append a SETPL instruction to the active function. 14444func (c *Context) SETPL(mr operand.Op) { 14445 if inst, err := x86.SETPL(mr); err == nil { 14446 c.Instruction(inst) 14447 } else { 14448 c.adderror(err) 14449 } 14450} 14451 14452// SETPL: Set byte if not sign (SF == 0). 14453// 14454// Forms: 14455// 14456// SETPL r8 14457// SETPL m8 14458// Construct and append a SETPL instruction to the active function. 14459// Operates on the global context. 14460func SETPL(mr operand.Op) { ctx.SETPL(mr) } 14461 14462// SETPS: Set byte if parity (PF == 1). 14463// 14464// Forms: 14465// 14466// SETPS r8 14467// SETPS m8 14468// Construct and append a SETPS instruction to the active function. 14469func (c *Context) SETPS(mr operand.Op) { 14470 if inst, err := x86.SETPS(mr); err == nil { 14471 c.Instruction(inst) 14472 } else { 14473 c.adderror(err) 14474 } 14475} 14476 14477// SETPS: Set byte if parity (PF == 1). 14478// 14479// Forms: 14480// 14481// SETPS r8 14482// SETPS m8 14483// Construct and append a SETPS instruction to the active function. 14484// Operates on the global context. 14485func SETPS(mr operand.Op) { ctx.SETPS(mr) } 14486 14487// SFENCE: Store Fence. 14488// 14489// Forms: 14490// 14491// SFENCE 14492// Construct and append a SFENCE instruction to the active function. 14493func (c *Context) SFENCE() { 14494 if inst, err := x86.SFENCE(); err == nil { 14495 c.Instruction(inst) 14496 } else { 14497 c.adderror(err) 14498 } 14499} 14500 14501// SFENCE: Store Fence. 14502// 14503// Forms: 14504// 14505// SFENCE 14506// Construct and append a SFENCE instruction to the active function. 14507// Operates on the global context. 14508func SFENCE() { ctx.SFENCE() } 14509 14510// SHA1MSG1: Perform an Intermediate Calculation for the Next Four SHA1 Message Doublewords. 14511// 14512// Forms: 14513// 14514// SHA1MSG1 xmm xmm 14515// SHA1MSG1 m128 xmm 14516// Construct and append a SHA1MSG1 instruction to the active function. 14517func (c *Context) SHA1MSG1(mx, x operand.Op) { 14518 if inst, err := x86.SHA1MSG1(mx, x); err == nil { 14519 c.Instruction(inst) 14520 } else { 14521 c.adderror(err) 14522 } 14523} 14524 14525// SHA1MSG1: Perform an Intermediate Calculation for the Next Four SHA1 Message Doublewords. 14526// 14527// Forms: 14528// 14529// SHA1MSG1 xmm xmm 14530// SHA1MSG1 m128 xmm 14531// Construct and append a SHA1MSG1 instruction to the active function. 14532// Operates on the global context. 14533func SHA1MSG1(mx, x operand.Op) { ctx.SHA1MSG1(mx, x) } 14534 14535// SHA1MSG2: Perform a Final Calculation for the Next Four SHA1 Message Doublewords. 14536// 14537// Forms: 14538// 14539// SHA1MSG2 xmm xmm 14540// SHA1MSG2 m128 xmm 14541// Construct and append a SHA1MSG2 instruction to the active function. 14542func (c *Context) SHA1MSG2(mx, x operand.Op) { 14543 if inst, err := x86.SHA1MSG2(mx, x); err == nil { 14544 c.Instruction(inst) 14545 } else { 14546 c.adderror(err) 14547 } 14548} 14549 14550// SHA1MSG2: Perform a Final Calculation for the Next Four SHA1 Message Doublewords. 14551// 14552// Forms: 14553// 14554// SHA1MSG2 xmm xmm 14555// SHA1MSG2 m128 xmm 14556// Construct and append a SHA1MSG2 instruction to the active function. 14557// Operates on the global context. 14558func SHA1MSG2(mx, x operand.Op) { ctx.SHA1MSG2(mx, x) } 14559 14560// SHA1NEXTE: Calculate SHA1 State Variable E after Four Rounds. 14561// 14562// Forms: 14563// 14564// SHA1NEXTE xmm xmm 14565// SHA1NEXTE m128 xmm 14566// Construct and append a SHA1NEXTE instruction to the active function. 14567func (c *Context) SHA1NEXTE(mx, x operand.Op) { 14568 if inst, err := x86.SHA1NEXTE(mx, x); err == nil { 14569 c.Instruction(inst) 14570 } else { 14571 c.adderror(err) 14572 } 14573} 14574 14575// SHA1NEXTE: Calculate SHA1 State Variable E after Four Rounds. 14576// 14577// Forms: 14578// 14579// SHA1NEXTE xmm xmm 14580// SHA1NEXTE m128 xmm 14581// Construct and append a SHA1NEXTE instruction to the active function. 14582// Operates on the global context. 14583func SHA1NEXTE(mx, x operand.Op) { ctx.SHA1NEXTE(mx, x) } 14584 14585// SHA1RNDS4: Perform Four Rounds of SHA1 Operation. 14586// 14587// Forms: 14588// 14589// SHA1RNDS4 imm2u xmm xmm 14590// SHA1RNDS4 imm2u m128 xmm 14591// Construct and append a SHA1RNDS4 instruction to the active function. 14592func (c *Context) SHA1RNDS4(i, mx, x operand.Op) { 14593 if inst, err := x86.SHA1RNDS4(i, mx, x); err == nil { 14594 c.Instruction(inst) 14595 } else { 14596 c.adderror(err) 14597 } 14598} 14599 14600// SHA1RNDS4: Perform Four Rounds of SHA1 Operation. 14601// 14602// Forms: 14603// 14604// SHA1RNDS4 imm2u xmm xmm 14605// SHA1RNDS4 imm2u m128 xmm 14606// Construct and append a SHA1RNDS4 instruction to the active function. 14607// Operates on the global context. 14608func SHA1RNDS4(i, mx, x operand.Op) { ctx.SHA1RNDS4(i, mx, x) } 14609 14610// SHA256MSG1: Perform an Intermediate Calculation for the Next Four SHA256 Message Doublewords. 14611// 14612// Forms: 14613// 14614// SHA256MSG1 xmm xmm 14615// SHA256MSG1 m128 xmm 14616// Construct and append a SHA256MSG1 instruction to the active function. 14617func (c *Context) SHA256MSG1(mx, x operand.Op) { 14618 if inst, err := x86.SHA256MSG1(mx, x); err == nil { 14619 c.Instruction(inst) 14620 } else { 14621 c.adderror(err) 14622 } 14623} 14624 14625// SHA256MSG1: Perform an Intermediate Calculation for the Next Four SHA256 Message Doublewords. 14626// 14627// Forms: 14628// 14629// SHA256MSG1 xmm xmm 14630// SHA256MSG1 m128 xmm 14631// Construct and append a SHA256MSG1 instruction to the active function. 14632// Operates on the global context. 14633func SHA256MSG1(mx, x operand.Op) { ctx.SHA256MSG1(mx, x) } 14634 14635// SHA256MSG2: Perform a Final Calculation for the Next Four SHA256 Message Doublewords. 14636// 14637// Forms: 14638// 14639// SHA256MSG2 xmm xmm 14640// SHA256MSG2 m128 xmm 14641// Construct and append a SHA256MSG2 instruction to the active function. 14642func (c *Context) SHA256MSG2(mx, x operand.Op) { 14643 if inst, err := x86.SHA256MSG2(mx, x); err == nil { 14644 c.Instruction(inst) 14645 } else { 14646 c.adderror(err) 14647 } 14648} 14649 14650// SHA256MSG2: Perform a Final Calculation for the Next Four SHA256 Message Doublewords. 14651// 14652// Forms: 14653// 14654// SHA256MSG2 xmm xmm 14655// SHA256MSG2 m128 xmm 14656// Construct and append a SHA256MSG2 instruction to the active function. 14657// Operates on the global context. 14658func SHA256MSG2(mx, x operand.Op) { ctx.SHA256MSG2(mx, x) } 14659 14660// SHA256RNDS2: Perform Two Rounds of SHA256 Operation. 14661// 14662// Forms: 14663// 14664// SHA256RNDS2 xmm0 xmm xmm 14665// SHA256RNDS2 xmm0 m128 xmm 14666// Construct and append a SHA256RNDS2 instruction to the active function. 14667func (c *Context) SHA256RNDS2(x, mx, x1 operand.Op) { 14668 if inst, err := x86.SHA256RNDS2(x, mx, x1); err == nil { 14669 c.Instruction(inst) 14670 } else { 14671 c.adderror(err) 14672 } 14673} 14674 14675// SHA256RNDS2: Perform Two Rounds of SHA256 Operation. 14676// 14677// Forms: 14678// 14679// SHA256RNDS2 xmm0 xmm xmm 14680// SHA256RNDS2 xmm0 m128 xmm 14681// Construct and append a SHA256RNDS2 instruction to the active function. 14682// Operates on the global context. 14683func SHA256RNDS2(x, mx, x1 operand.Op) { ctx.SHA256RNDS2(x, mx, x1) } 14684 14685// SHLB: Logical Shift Left. 14686// 14687// Forms: 14688// 14689// SHLB 1 r8 14690// SHLB imm8 r8 14691// SHLB cl r8 14692// SHLB 1 m8 14693// SHLB imm8 m8 14694// SHLB cl m8 14695// Construct and append a SHLB instruction to the active function. 14696func (c *Context) SHLB(ci, mr operand.Op) { 14697 if inst, err := x86.SHLB(ci, mr); err == nil { 14698 c.Instruction(inst) 14699 } else { 14700 c.adderror(err) 14701 } 14702} 14703 14704// SHLB: Logical Shift Left. 14705// 14706// Forms: 14707// 14708// SHLB 1 r8 14709// SHLB imm8 r8 14710// SHLB cl r8 14711// SHLB 1 m8 14712// SHLB imm8 m8 14713// SHLB cl m8 14714// Construct and append a SHLB instruction to the active function. 14715// Operates on the global context. 14716func SHLB(ci, mr operand.Op) { ctx.SHLB(ci, mr) } 14717 14718// SHLL: Logical Shift Left. 14719// 14720// Forms: 14721// 14722// SHLL 1 r32 14723// SHLL imm8 r32 14724// SHLL cl r32 14725// SHLL 1 m32 14726// SHLL imm8 m32 14727// SHLL cl m32 14728// SHLL imm8 r32 r32 14729// SHLL cl r32 r32 14730// SHLL imm8 r32 m32 14731// SHLL cl r32 m32 14732// Construct and append a SHLL instruction to the active function. 14733func (c *Context) SHLL(ops ...operand.Op) { 14734 if inst, err := x86.SHLL(ops...); err == nil { 14735 c.Instruction(inst) 14736 } else { 14737 c.adderror(err) 14738 } 14739} 14740 14741// SHLL: Logical Shift Left. 14742// 14743// Forms: 14744// 14745// SHLL 1 r32 14746// SHLL imm8 r32 14747// SHLL cl r32 14748// SHLL 1 m32 14749// SHLL imm8 m32 14750// SHLL cl m32 14751// SHLL imm8 r32 r32 14752// SHLL cl r32 r32 14753// SHLL imm8 r32 m32 14754// SHLL cl r32 m32 14755// Construct and append a SHLL instruction to the active function. 14756// Operates on the global context. 14757func SHLL(ops ...operand.Op) { ctx.SHLL(ops...) } 14758 14759// SHLQ: Logical Shift Left. 14760// 14761// Forms: 14762// 14763// SHLQ 1 r64 14764// SHLQ imm8 r64 14765// SHLQ cl r64 14766// SHLQ 1 m64 14767// SHLQ imm8 m64 14768// SHLQ cl m64 14769// SHLQ imm8 r64 r64 14770// SHLQ cl r64 r64 14771// SHLQ imm8 r64 m64 14772// SHLQ cl r64 m64 14773// Construct and append a SHLQ instruction to the active function. 14774func (c *Context) SHLQ(ops ...operand.Op) { 14775 if inst, err := x86.SHLQ(ops...); err == nil { 14776 c.Instruction(inst) 14777 } else { 14778 c.adderror(err) 14779 } 14780} 14781 14782// SHLQ: Logical Shift Left. 14783// 14784// Forms: 14785// 14786// SHLQ 1 r64 14787// SHLQ imm8 r64 14788// SHLQ cl r64 14789// SHLQ 1 m64 14790// SHLQ imm8 m64 14791// SHLQ cl m64 14792// SHLQ imm8 r64 r64 14793// SHLQ cl r64 r64 14794// SHLQ imm8 r64 m64 14795// SHLQ cl r64 m64 14796// Construct and append a SHLQ instruction to the active function. 14797// Operates on the global context. 14798func SHLQ(ops ...operand.Op) { ctx.SHLQ(ops...) } 14799 14800// SHLW: Logical Shift Left. 14801// 14802// Forms: 14803// 14804// SHLW 1 r16 14805// SHLW imm8 r16 14806// SHLW cl r16 14807// SHLW 1 m16 14808// SHLW imm8 m16 14809// SHLW cl m16 14810// SHLW imm8 r16 r16 14811// SHLW cl r16 r16 14812// SHLW imm8 r16 m16 14813// SHLW cl r16 m16 14814// Construct and append a SHLW instruction to the active function. 14815func (c *Context) SHLW(ops ...operand.Op) { 14816 if inst, err := x86.SHLW(ops...); err == nil { 14817 c.Instruction(inst) 14818 } else { 14819 c.adderror(err) 14820 } 14821} 14822 14823// SHLW: Logical Shift Left. 14824// 14825// Forms: 14826// 14827// SHLW 1 r16 14828// SHLW imm8 r16 14829// SHLW cl r16 14830// SHLW 1 m16 14831// SHLW imm8 m16 14832// SHLW cl m16 14833// SHLW imm8 r16 r16 14834// SHLW cl r16 r16 14835// SHLW imm8 r16 m16 14836// SHLW cl r16 m16 14837// Construct and append a SHLW instruction to the active function. 14838// Operates on the global context. 14839func SHLW(ops ...operand.Op) { ctx.SHLW(ops...) } 14840 14841// SHLXL: Logical Shift Left Without Affecting Flags. 14842// 14843// Forms: 14844// 14845// SHLXL r32 r32 r32 14846// SHLXL r32 m32 r32 14847// Construct and append a SHLXL instruction to the active function. 14848func (c *Context) SHLXL(r, mr, r1 operand.Op) { 14849 if inst, err := x86.SHLXL(r, mr, r1); err == nil { 14850 c.Instruction(inst) 14851 } else { 14852 c.adderror(err) 14853 } 14854} 14855 14856// SHLXL: Logical Shift Left Without Affecting Flags. 14857// 14858// Forms: 14859// 14860// SHLXL r32 r32 r32 14861// SHLXL r32 m32 r32 14862// Construct and append a SHLXL instruction to the active function. 14863// Operates on the global context. 14864func SHLXL(r, mr, r1 operand.Op) { ctx.SHLXL(r, mr, r1) } 14865 14866// SHLXQ: Logical Shift Left Without Affecting Flags. 14867// 14868// Forms: 14869// 14870// SHLXQ r64 r64 r64 14871// SHLXQ r64 m64 r64 14872// Construct and append a SHLXQ instruction to the active function. 14873func (c *Context) SHLXQ(r, mr, r1 operand.Op) { 14874 if inst, err := x86.SHLXQ(r, mr, r1); err == nil { 14875 c.Instruction(inst) 14876 } else { 14877 c.adderror(err) 14878 } 14879} 14880 14881// SHLXQ: Logical Shift Left Without Affecting Flags. 14882// 14883// Forms: 14884// 14885// SHLXQ r64 r64 r64 14886// SHLXQ r64 m64 r64 14887// Construct and append a SHLXQ instruction to the active function. 14888// Operates on the global context. 14889func SHLXQ(r, mr, r1 operand.Op) { ctx.SHLXQ(r, mr, r1) } 14890 14891// SHRB: Logical Shift Right. 14892// 14893// Forms: 14894// 14895// SHRB 1 r8 14896// SHRB imm8 r8 14897// SHRB cl r8 14898// SHRB 1 m8 14899// SHRB imm8 m8 14900// SHRB cl m8 14901// Construct and append a SHRB instruction to the active function. 14902func (c *Context) SHRB(ci, mr operand.Op) { 14903 if inst, err := x86.SHRB(ci, mr); err == nil { 14904 c.Instruction(inst) 14905 } else { 14906 c.adderror(err) 14907 } 14908} 14909 14910// SHRB: Logical Shift Right. 14911// 14912// Forms: 14913// 14914// SHRB 1 r8 14915// SHRB imm8 r8 14916// SHRB cl r8 14917// SHRB 1 m8 14918// SHRB imm8 m8 14919// SHRB cl m8 14920// Construct and append a SHRB instruction to the active function. 14921// Operates on the global context. 14922func SHRB(ci, mr operand.Op) { ctx.SHRB(ci, mr) } 14923 14924// SHRL: Logical Shift Right. 14925// 14926// Forms: 14927// 14928// SHRL 1 r32 14929// SHRL imm8 r32 14930// SHRL cl r32 14931// SHRL 1 m32 14932// SHRL imm8 m32 14933// SHRL cl m32 14934// SHRL imm8 r32 r32 14935// SHRL cl r32 r32 14936// SHRL imm8 r32 m32 14937// SHRL cl r32 m32 14938// Construct and append a SHRL instruction to the active function. 14939func (c *Context) SHRL(ops ...operand.Op) { 14940 if inst, err := x86.SHRL(ops...); err == nil { 14941 c.Instruction(inst) 14942 } else { 14943 c.adderror(err) 14944 } 14945} 14946 14947// SHRL: Logical Shift Right. 14948// 14949// Forms: 14950// 14951// SHRL 1 r32 14952// SHRL imm8 r32 14953// SHRL cl r32 14954// SHRL 1 m32 14955// SHRL imm8 m32 14956// SHRL cl m32 14957// SHRL imm8 r32 r32 14958// SHRL cl r32 r32 14959// SHRL imm8 r32 m32 14960// SHRL cl r32 m32 14961// Construct and append a SHRL instruction to the active function. 14962// Operates on the global context. 14963func SHRL(ops ...operand.Op) { ctx.SHRL(ops...) } 14964 14965// SHRQ: Logical Shift Right. 14966// 14967// Forms: 14968// 14969// SHRQ 1 r64 14970// SHRQ imm8 r64 14971// SHRQ cl r64 14972// SHRQ 1 m64 14973// SHRQ imm8 m64 14974// SHRQ cl m64 14975// SHRQ imm8 r64 r64 14976// SHRQ cl r64 r64 14977// SHRQ imm8 r64 m64 14978// SHRQ cl r64 m64 14979// Construct and append a SHRQ instruction to the active function. 14980func (c *Context) SHRQ(ops ...operand.Op) { 14981 if inst, err := x86.SHRQ(ops...); err == nil { 14982 c.Instruction(inst) 14983 } else { 14984 c.adderror(err) 14985 } 14986} 14987 14988// SHRQ: Logical Shift Right. 14989// 14990// Forms: 14991// 14992// SHRQ 1 r64 14993// SHRQ imm8 r64 14994// SHRQ cl r64 14995// SHRQ 1 m64 14996// SHRQ imm8 m64 14997// SHRQ cl m64 14998// SHRQ imm8 r64 r64 14999// SHRQ cl r64 r64 15000// SHRQ imm8 r64 m64 15001// SHRQ cl r64 m64 15002// Construct and append a SHRQ instruction to the active function. 15003// Operates on the global context. 15004func SHRQ(ops ...operand.Op) { ctx.SHRQ(ops...) } 15005 15006// SHRW: Logical Shift Right. 15007// 15008// Forms: 15009// 15010// SHRW 1 r16 15011// SHRW imm8 r16 15012// SHRW cl r16 15013// SHRW 1 m16 15014// SHRW imm8 m16 15015// SHRW cl m16 15016// SHRW imm8 r16 r16 15017// SHRW cl r16 r16 15018// SHRW imm8 r16 m16 15019// SHRW cl r16 m16 15020// Construct and append a SHRW instruction to the active function. 15021func (c *Context) SHRW(ops ...operand.Op) { 15022 if inst, err := x86.SHRW(ops...); err == nil { 15023 c.Instruction(inst) 15024 } else { 15025 c.adderror(err) 15026 } 15027} 15028 15029// SHRW: Logical Shift Right. 15030// 15031// Forms: 15032// 15033// SHRW 1 r16 15034// SHRW imm8 r16 15035// SHRW cl r16 15036// SHRW 1 m16 15037// SHRW imm8 m16 15038// SHRW cl m16 15039// SHRW imm8 r16 r16 15040// SHRW cl r16 r16 15041// SHRW imm8 r16 m16 15042// SHRW cl r16 m16 15043// Construct and append a SHRW instruction to the active function. 15044// Operates on the global context. 15045func SHRW(ops ...operand.Op) { ctx.SHRW(ops...) } 15046 15047// SHRXL: Logical Shift Right Without Affecting Flags. 15048// 15049// Forms: 15050// 15051// SHRXL r32 r32 r32 15052// SHRXL r32 m32 r32 15053// Construct and append a SHRXL instruction to the active function. 15054func (c *Context) SHRXL(r, mr, r1 operand.Op) { 15055 if inst, err := x86.SHRXL(r, mr, r1); err == nil { 15056 c.Instruction(inst) 15057 } else { 15058 c.adderror(err) 15059 } 15060} 15061 15062// SHRXL: Logical Shift Right Without Affecting Flags. 15063// 15064// Forms: 15065// 15066// SHRXL r32 r32 r32 15067// SHRXL r32 m32 r32 15068// Construct and append a SHRXL instruction to the active function. 15069// Operates on the global context. 15070func SHRXL(r, mr, r1 operand.Op) { ctx.SHRXL(r, mr, r1) } 15071 15072// SHRXQ: Logical Shift Right Without Affecting Flags. 15073// 15074// Forms: 15075// 15076// SHRXQ r64 r64 r64 15077// SHRXQ r64 m64 r64 15078// Construct and append a SHRXQ instruction to the active function. 15079func (c *Context) SHRXQ(r, mr, r1 operand.Op) { 15080 if inst, err := x86.SHRXQ(r, mr, r1); err == nil { 15081 c.Instruction(inst) 15082 } else { 15083 c.adderror(err) 15084 } 15085} 15086 15087// SHRXQ: Logical Shift Right Without Affecting Flags. 15088// 15089// Forms: 15090// 15091// SHRXQ r64 r64 r64 15092// SHRXQ r64 m64 r64 15093// Construct and append a SHRXQ instruction to the active function. 15094// Operates on the global context. 15095func SHRXQ(r, mr, r1 operand.Op) { ctx.SHRXQ(r, mr, r1) } 15096 15097// SHUFPD: Shuffle Packed Double-Precision Floating-Point Values. 15098// 15099// Forms: 15100// 15101// SHUFPD imm8 xmm xmm 15102// SHUFPD imm8 m128 xmm 15103// Construct and append a SHUFPD instruction to the active function. 15104func (c *Context) SHUFPD(i, mx, x operand.Op) { 15105 if inst, err := x86.SHUFPD(i, mx, x); err == nil { 15106 c.Instruction(inst) 15107 } else { 15108 c.adderror(err) 15109 } 15110} 15111 15112// SHUFPD: Shuffle Packed Double-Precision Floating-Point Values. 15113// 15114// Forms: 15115// 15116// SHUFPD imm8 xmm xmm 15117// SHUFPD imm8 m128 xmm 15118// Construct and append a SHUFPD instruction to the active function. 15119// Operates on the global context. 15120func SHUFPD(i, mx, x operand.Op) { ctx.SHUFPD(i, mx, x) } 15121 15122// SHUFPS: Shuffle Packed Single-Precision Floating-Point Values. 15123// 15124// Forms: 15125// 15126// SHUFPS imm8 xmm xmm 15127// SHUFPS imm8 m128 xmm 15128// Construct and append a SHUFPS instruction to the active function. 15129func (c *Context) SHUFPS(i, mx, x operand.Op) { 15130 if inst, err := x86.SHUFPS(i, mx, x); err == nil { 15131 c.Instruction(inst) 15132 } else { 15133 c.adderror(err) 15134 } 15135} 15136 15137// SHUFPS: Shuffle Packed Single-Precision Floating-Point Values. 15138// 15139// Forms: 15140// 15141// SHUFPS imm8 xmm xmm 15142// SHUFPS imm8 m128 xmm 15143// Construct and append a SHUFPS instruction to the active function. 15144// Operates on the global context. 15145func SHUFPS(i, mx, x operand.Op) { ctx.SHUFPS(i, mx, x) } 15146 15147// SQRTPD: Compute Square Roots of Packed Double-Precision Floating-Point Values. 15148// 15149// Forms: 15150// 15151// SQRTPD xmm xmm 15152// SQRTPD m128 xmm 15153// Construct and append a SQRTPD instruction to the active function. 15154func (c *Context) SQRTPD(mx, x operand.Op) { 15155 if inst, err := x86.SQRTPD(mx, x); err == nil { 15156 c.Instruction(inst) 15157 } else { 15158 c.adderror(err) 15159 } 15160} 15161 15162// SQRTPD: Compute Square Roots of Packed Double-Precision Floating-Point Values. 15163// 15164// Forms: 15165// 15166// SQRTPD xmm xmm 15167// SQRTPD m128 xmm 15168// Construct and append a SQRTPD instruction to the active function. 15169// Operates on the global context. 15170func SQRTPD(mx, x operand.Op) { ctx.SQRTPD(mx, x) } 15171 15172// SQRTPS: Compute Square Roots of Packed Single-Precision Floating-Point Values. 15173// 15174// Forms: 15175// 15176// SQRTPS xmm xmm 15177// SQRTPS m128 xmm 15178// Construct and append a SQRTPS instruction to the active function. 15179func (c *Context) SQRTPS(mx, x operand.Op) { 15180 if inst, err := x86.SQRTPS(mx, x); err == nil { 15181 c.Instruction(inst) 15182 } else { 15183 c.adderror(err) 15184 } 15185} 15186 15187// SQRTPS: Compute Square Roots of Packed Single-Precision Floating-Point Values. 15188// 15189// Forms: 15190// 15191// SQRTPS xmm xmm 15192// SQRTPS m128 xmm 15193// Construct and append a SQRTPS instruction to the active function. 15194// Operates on the global context. 15195func SQRTPS(mx, x operand.Op) { ctx.SQRTPS(mx, x) } 15196 15197// SQRTSD: Compute Square Root of Scalar Double-Precision Floating-Point Value. 15198// 15199// Forms: 15200// 15201// SQRTSD xmm xmm 15202// SQRTSD m64 xmm 15203// Construct and append a SQRTSD instruction to the active function. 15204func (c *Context) SQRTSD(mx, x operand.Op) { 15205 if inst, err := x86.SQRTSD(mx, x); err == nil { 15206 c.Instruction(inst) 15207 } else { 15208 c.adderror(err) 15209 } 15210} 15211 15212// SQRTSD: Compute Square Root of Scalar Double-Precision Floating-Point Value. 15213// 15214// Forms: 15215// 15216// SQRTSD xmm xmm 15217// SQRTSD m64 xmm 15218// Construct and append a SQRTSD instruction to the active function. 15219// Operates on the global context. 15220func SQRTSD(mx, x operand.Op) { ctx.SQRTSD(mx, x) } 15221 15222// SQRTSS: Compute Square Root of Scalar Single-Precision Floating-Point Value. 15223// 15224// Forms: 15225// 15226// SQRTSS xmm xmm 15227// SQRTSS m32 xmm 15228// Construct and append a SQRTSS instruction to the active function. 15229func (c *Context) SQRTSS(mx, x operand.Op) { 15230 if inst, err := x86.SQRTSS(mx, x); err == nil { 15231 c.Instruction(inst) 15232 } else { 15233 c.adderror(err) 15234 } 15235} 15236 15237// SQRTSS: Compute Square Root of Scalar Single-Precision Floating-Point Value. 15238// 15239// Forms: 15240// 15241// SQRTSS xmm xmm 15242// SQRTSS m32 xmm 15243// Construct and append a SQRTSS instruction to the active function. 15244// Operates on the global context. 15245func SQRTSS(mx, x operand.Op) { ctx.SQRTSS(mx, x) } 15246 15247// STC: Set Carry Flag. 15248// 15249// Forms: 15250// 15251// STC 15252// Construct and append a STC instruction to the active function. 15253func (c *Context) STC() { 15254 if inst, err := x86.STC(); err == nil { 15255 c.Instruction(inst) 15256 } else { 15257 c.adderror(err) 15258 } 15259} 15260 15261// STC: Set Carry Flag. 15262// 15263// Forms: 15264// 15265// STC 15266// Construct and append a STC instruction to the active function. 15267// Operates on the global context. 15268func STC() { ctx.STC() } 15269 15270// STD: Set Direction Flag. 15271// 15272// Forms: 15273// 15274// STD 15275// Construct and append a STD instruction to the active function. 15276func (c *Context) STD() { 15277 if inst, err := x86.STD(); err == nil { 15278 c.Instruction(inst) 15279 } else { 15280 c.adderror(err) 15281 } 15282} 15283 15284// STD: Set Direction Flag. 15285// 15286// Forms: 15287// 15288// STD 15289// Construct and append a STD instruction to the active function. 15290// Operates on the global context. 15291func STD() { ctx.STD() } 15292 15293// STMXCSR: Store MXCSR Register State. 15294// 15295// Forms: 15296// 15297// STMXCSR m32 15298// Construct and append a STMXCSR instruction to the active function. 15299func (c *Context) STMXCSR(m operand.Op) { 15300 if inst, err := x86.STMXCSR(m); err == nil { 15301 c.Instruction(inst) 15302 } else { 15303 c.adderror(err) 15304 } 15305} 15306 15307// STMXCSR: Store MXCSR Register State. 15308// 15309// Forms: 15310// 15311// STMXCSR m32 15312// Construct and append a STMXCSR instruction to the active function. 15313// Operates on the global context. 15314func STMXCSR(m operand.Op) { ctx.STMXCSR(m) } 15315 15316// SUBB: Subtract. 15317// 15318// Forms: 15319// 15320// SUBB imm8 al 15321// SUBB imm8 r8 15322// SUBB r8 r8 15323// SUBB m8 r8 15324// SUBB imm8 m8 15325// SUBB r8 m8 15326// Construct and append a SUBB instruction to the active function. 15327func (c *Context) SUBB(imr, amr operand.Op) { 15328 if inst, err := x86.SUBB(imr, amr); err == nil { 15329 c.Instruction(inst) 15330 } else { 15331 c.adderror(err) 15332 } 15333} 15334 15335// SUBB: Subtract. 15336// 15337// Forms: 15338// 15339// SUBB imm8 al 15340// SUBB imm8 r8 15341// SUBB r8 r8 15342// SUBB m8 r8 15343// SUBB imm8 m8 15344// SUBB r8 m8 15345// Construct and append a SUBB instruction to the active function. 15346// Operates on the global context. 15347func SUBB(imr, amr operand.Op) { ctx.SUBB(imr, amr) } 15348 15349// SUBL: Subtract. 15350// 15351// Forms: 15352// 15353// SUBL imm32 eax 15354// SUBL imm8 r32 15355// SUBL imm32 r32 15356// SUBL r32 r32 15357// SUBL m32 r32 15358// SUBL imm8 m32 15359// SUBL imm32 m32 15360// SUBL r32 m32 15361// Construct and append a SUBL instruction to the active function. 15362func (c *Context) SUBL(imr, emr operand.Op) { 15363 if inst, err := x86.SUBL(imr, emr); err == nil { 15364 c.Instruction(inst) 15365 } else { 15366 c.adderror(err) 15367 } 15368} 15369 15370// SUBL: Subtract. 15371// 15372// Forms: 15373// 15374// SUBL imm32 eax 15375// SUBL imm8 r32 15376// SUBL imm32 r32 15377// SUBL r32 r32 15378// SUBL m32 r32 15379// SUBL imm8 m32 15380// SUBL imm32 m32 15381// SUBL r32 m32 15382// Construct and append a SUBL instruction to the active function. 15383// Operates on the global context. 15384func SUBL(imr, emr operand.Op) { ctx.SUBL(imr, emr) } 15385 15386// SUBPD: Subtract Packed Double-Precision Floating-Point Values. 15387// 15388// Forms: 15389// 15390// SUBPD xmm xmm 15391// SUBPD m128 xmm 15392// Construct and append a SUBPD instruction to the active function. 15393func (c *Context) SUBPD(mx, x operand.Op) { 15394 if inst, err := x86.SUBPD(mx, x); err == nil { 15395 c.Instruction(inst) 15396 } else { 15397 c.adderror(err) 15398 } 15399} 15400 15401// SUBPD: Subtract Packed Double-Precision Floating-Point Values. 15402// 15403// Forms: 15404// 15405// SUBPD xmm xmm 15406// SUBPD m128 xmm 15407// Construct and append a SUBPD instruction to the active function. 15408// Operates on the global context. 15409func SUBPD(mx, x operand.Op) { ctx.SUBPD(mx, x) } 15410 15411// SUBPS: Subtract Packed Single-Precision Floating-Point Values. 15412// 15413// Forms: 15414// 15415// SUBPS xmm xmm 15416// SUBPS m128 xmm 15417// Construct and append a SUBPS instruction to the active function. 15418func (c *Context) SUBPS(mx, x operand.Op) { 15419 if inst, err := x86.SUBPS(mx, x); err == nil { 15420 c.Instruction(inst) 15421 } else { 15422 c.adderror(err) 15423 } 15424} 15425 15426// SUBPS: Subtract Packed Single-Precision Floating-Point Values. 15427// 15428// Forms: 15429// 15430// SUBPS xmm xmm 15431// SUBPS m128 xmm 15432// Construct and append a SUBPS instruction to the active function. 15433// Operates on the global context. 15434func SUBPS(mx, x operand.Op) { ctx.SUBPS(mx, x) } 15435 15436// SUBQ: Subtract. 15437// 15438// Forms: 15439// 15440// SUBQ imm32 rax 15441// SUBQ imm8 r64 15442// SUBQ imm32 r64 15443// SUBQ r64 r64 15444// SUBQ m64 r64 15445// SUBQ imm8 m64 15446// SUBQ imm32 m64 15447// SUBQ r64 m64 15448// Construct and append a SUBQ instruction to the active function. 15449func (c *Context) SUBQ(imr, mr operand.Op) { 15450 if inst, err := x86.SUBQ(imr, mr); err == nil { 15451 c.Instruction(inst) 15452 } else { 15453 c.adderror(err) 15454 } 15455} 15456 15457// SUBQ: Subtract. 15458// 15459// Forms: 15460// 15461// SUBQ imm32 rax 15462// SUBQ imm8 r64 15463// SUBQ imm32 r64 15464// SUBQ r64 r64 15465// SUBQ m64 r64 15466// SUBQ imm8 m64 15467// SUBQ imm32 m64 15468// SUBQ r64 m64 15469// Construct and append a SUBQ instruction to the active function. 15470// Operates on the global context. 15471func SUBQ(imr, mr operand.Op) { ctx.SUBQ(imr, mr) } 15472 15473// SUBSD: Subtract Scalar Double-Precision Floating-Point Values. 15474// 15475// Forms: 15476// 15477// SUBSD xmm xmm 15478// SUBSD m64 xmm 15479// Construct and append a SUBSD instruction to the active function. 15480func (c *Context) SUBSD(mx, x operand.Op) { 15481 if inst, err := x86.SUBSD(mx, x); err == nil { 15482 c.Instruction(inst) 15483 } else { 15484 c.adderror(err) 15485 } 15486} 15487 15488// SUBSD: Subtract Scalar Double-Precision Floating-Point Values. 15489// 15490// Forms: 15491// 15492// SUBSD xmm xmm 15493// SUBSD m64 xmm 15494// Construct and append a SUBSD instruction to the active function. 15495// Operates on the global context. 15496func SUBSD(mx, x operand.Op) { ctx.SUBSD(mx, x) } 15497 15498// SUBSS: Subtract Scalar Single-Precision Floating-Point Values. 15499// 15500// Forms: 15501// 15502// SUBSS xmm xmm 15503// SUBSS m32 xmm 15504// Construct and append a SUBSS instruction to the active function. 15505func (c *Context) SUBSS(mx, x operand.Op) { 15506 if inst, err := x86.SUBSS(mx, x); err == nil { 15507 c.Instruction(inst) 15508 } else { 15509 c.adderror(err) 15510 } 15511} 15512 15513// SUBSS: Subtract Scalar Single-Precision Floating-Point Values. 15514// 15515// Forms: 15516// 15517// SUBSS xmm xmm 15518// SUBSS m32 xmm 15519// Construct and append a SUBSS instruction to the active function. 15520// Operates on the global context. 15521func SUBSS(mx, x operand.Op) { ctx.SUBSS(mx, x) } 15522 15523// SUBW: Subtract. 15524// 15525// Forms: 15526// 15527// SUBW imm16 ax 15528// SUBW imm8 r16 15529// SUBW imm16 r16 15530// SUBW r16 r16 15531// SUBW m16 r16 15532// SUBW imm8 m16 15533// SUBW imm16 m16 15534// SUBW r16 m16 15535// Construct and append a SUBW instruction to the active function. 15536func (c *Context) SUBW(imr, amr operand.Op) { 15537 if inst, err := x86.SUBW(imr, amr); err == nil { 15538 c.Instruction(inst) 15539 } else { 15540 c.adderror(err) 15541 } 15542} 15543 15544// SUBW: Subtract. 15545// 15546// Forms: 15547// 15548// SUBW imm16 ax 15549// SUBW imm8 r16 15550// SUBW imm16 r16 15551// SUBW r16 r16 15552// SUBW m16 r16 15553// SUBW imm8 m16 15554// SUBW imm16 m16 15555// SUBW r16 m16 15556// Construct and append a SUBW instruction to the active function. 15557// Operates on the global context. 15558func SUBW(imr, amr operand.Op) { ctx.SUBW(imr, amr) } 15559 15560// SYSCALL: Fast System Call. 15561// 15562// Forms: 15563// 15564// SYSCALL 15565// Construct and append a SYSCALL instruction to the active function. 15566func (c *Context) SYSCALL() { 15567 if inst, err := x86.SYSCALL(); err == nil { 15568 c.Instruction(inst) 15569 } else { 15570 c.adderror(err) 15571 } 15572} 15573 15574// SYSCALL: Fast System Call. 15575// 15576// Forms: 15577// 15578// SYSCALL 15579// Construct and append a SYSCALL instruction to the active function. 15580// Operates on the global context. 15581func SYSCALL() { ctx.SYSCALL() } 15582 15583// TESTB: Logical Compare. 15584// 15585// Forms: 15586// 15587// TESTB imm8 al 15588// TESTB imm8 r8 15589// TESTB r8 r8 15590// TESTB imm8 m8 15591// TESTB r8 m8 15592// Construct and append a TESTB instruction to the active function. 15593func (c *Context) TESTB(ir, amr operand.Op) { 15594 if inst, err := x86.TESTB(ir, amr); err == nil { 15595 c.Instruction(inst) 15596 } else { 15597 c.adderror(err) 15598 } 15599} 15600 15601// TESTB: Logical Compare. 15602// 15603// Forms: 15604// 15605// TESTB imm8 al 15606// TESTB imm8 r8 15607// TESTB r8 r8 15608// TESTB imm8 m8 15609// TESTB r8 m8 15610// Construct and append a TESTB instruction to the active function. 15611// Operates on the global context. 15612func TESTB(ir, amr operand.Op) { ctx.TESTB(ir, amr) } 15613 15614// TESTL: Logical Compare. 15615// 15616// Forms: 15617// 15618// TESTL imm32 eax 15619// TESTL imm32 r32 15620// TESTL r32 r32 15621// TESTL imm32 m32 15622// TESTL r32 m32 15623// Construct and append a TESTL instruction to the active function. 15624func (c *Context) TESTL(ir, emr operand.Op) { 15625 if inst, err := x86.TESTL(ir, emr); err == nil { 15626 c.Instruction(inst) 15627 } else { 15628 c.adderror(err) 15629 } 15630} 15631 15632// TESTL: Logical Compare. 15633// 15634// Forms: 15635// 15636// TESTL imm32 eax 15637// TESTL imm32 r32 15638// TESTL r32 r32 15639// TESTL imm32 m32 15640// TESTL r32 m32 15641// Construct and append a TESTL instruction to the active function. 15642// Operates on the global context. 15643func TESTL(ir, emr operand.Op) { ctx.TESTL(ir, emr) } 15644 15645// TESTQ: Logical Compare. 15646// 15647// Forms: 15648// 15649// TESTQ imm32 rax 15650// TESTQ imm32 r64 15651// TESTQ r64 r64 15652// TESTQ imm32 m64 15653// TESTQ r64 m64 15654// Construct and append a TESTQ instruction to the active function. 15655func (c *Context) TESTQ(ir, mr operand.Op) { 15656 if inst, err := x86.TESTQ(ir, mr); err == nil { 15657 c.Instruction(inst) 15658 } else { 15659 c.adderror(err) 15660 } 15661} 15662 15663// TESTQ: Logical Compare. 15664// 15665// Forms: 15666// 15667// TESTQ imm32 rax 15668// TESTQ imm32 r64 15669// TESTQ r64 r64 15670// TESTQ imm32 m64 15671// TESTQ r64 m64 15672// Construct and append a TESTQ instruction to the active function. 15673// Operates on the global context. 15674func TESTQ(ir, mr operand.Op) { ctx.TESTQ(ir, mr) } 15675 15676// TESTW: Logical Compare. 15677// 15678// Forms: 15679// 15680// TESTW imm16 ax 15681// TESTW imm16 r16 15682// TESTW r16 r16 15683// TESTW imm16 m16 15684// TESTW r16 m16 15685// Construct and append a TESTW instruction to the active function. 15686func (c *Context) TESTW(ir, amr operand.Op) { 15687 if inst, err := x86.TESTW(ir, amr); err == nil { 15688 c.Instruction(inst) 15689 } else { 15690 c.adderror(err) 15691 } 15692} 15693 15694// TESTW: Logical Compare. 15695// 15696// Forms: 15697// 15698// TESTW imm16 ax 15699// TESTW imm16 r16 15700// TESTW r16 r16 15701// TESTW imm16 m16 15702// TESTW r16 m16 15703// Construct and append a TESTW instruction to the active function. 15704// Operates on the global context. 15705func TESTW(ir, amr operand.Op) { ctx.TESTW(ir, amr) } 15706 15707// TZCNTL: Count the Number of Trailing Zero Bits. 15708// 15709// Forms: 15710// 15711// TZCNTL r32 r32 15712// TZCNTL m32 r32 15713// Construct and append a TZCNTL instruction to the active function. 15714func (c *Context) TZCNTL(mr, r operand.Op) { 15715 if inst, err := x86.TZCNTL(mr, r); err == nil { 15716 c.Instruction(inst) 15717 } else { 15718 c.adderror(err) 15719 } 15720} 15721 15722// TZCNTL: Count the Number of Trailing Zero Bits. 15723// 15724// Forms: 15725// 15726// TZCNTL r32 r32 15727// TZCNTL m32 r32 15728// Construct and append a TZCNTL instruction to the active function. 15729// Operates on the global context. 15730func TZCNTL(mr, r operand.Op) { ctx.TZCNTL(mr, r) } 15731 15732// TZCNTQ: Count the Number of Trailing Zero Bits. 15733// 15734// Forms: 15735// 15736// TZCNTQ r64 r64 15737// TZCNTQ m64 r64 15738// Construct and append a TZCNTQ instruction to the active function. 15739func (c *Context) TZCNTQ(mr, r operand.Op) { 15740 if inst, err := x86.TZCNTQ(mr, r); err == nil { 15741 c.Instruction(inst) 15742 } else { 15743 c.adderror(err) 15744 } 15745} 15746 15747// TZCNTQ: Count the Number of Trailing Zero Bits. 15748// 15749// Forms: 15750// 15751// TZCNTQ r64 r64 15752// TZCNTQ m64 r64 15753// Construct and append a TZCNTQ instruction to the active function. 15754// Operates on the global context. 15755func TZCNTQ(mr, r operand.Op) { ctx.TZCNTQ(mr, r) } 15756 15757// TZCNTW: Count the Number of Trailing Zero Bits. 15758// 15759// Forms: 15760// 15761// TZCNTW r16 r16 15762// TZCNTW m16 r16 15763// Construct and append a TZCNTW instruction to the active function. 15764func (c *Context) TZCNTW(mr, r operand.Op) { 15765 if inst, err := x86.TZCNTW(mr, r); err == nil { 15766 c.Instruction(inst) 15767 } else { 15768 c.adderror(err) 15769 } 15770} 15771 15772// TZCNTW: Count the Number of Trailing Zero Bits. 15773// 15774// Forms: 15775// 15776// TZCNTW r16 r16 15777// TZCNTW m16 r16 15778// Construct and append a TZCNTW instruction to the active function. 15779// Operates on the global context. 15780func TZCNTW(mr, r operand.Op) { ctx.TZCNTW(mr, r) } 15781 15782// UCOMISD: Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS. 15783// 15784// Forms: 15785// 15786// UCOMISD xmm xmm 15787// UCOMISD m64 xmm 15788// Construct and append a UCOMISD instruction to the active function. 15789func (c *Context) UCOMISD(mx, x operand.Op) { 15790 if inst, err := x86.UCOMISD(mx, x); err == nil { 15791 c.Instruction(inst) 15792 } else { 15793 c.adderror(err) 15794 } 15795} 15796 15797// UCOMISD: Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS. 15798// 15799// Forms: 15800// 15801// UCOMISD xmm xmm 15802// UCOMISD m64 xmm 15803// Construct and append a UCOMISD instruction to the active function. 15804// Operates on the global context. 15805func UCOMISD(mx, x operand.Op) { ctx.UCOMISD(mx, x) } 15806 15807// UCOMISS: Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS. 15808// 15809// Forms: 15810// 15811// UCOMISS xmm xmm 15812// UCOMISS m32 xmm 15813// Construct and append a UCOMISS instruction to the active function. 15814func (c *Context) UCOMISS(mx, x operand.Op) { 15815 if inst, err := x86.UCOMISS(mx, x); err == nil { 15816 c.Instruction(inst) 15817 } else { 15818 c.adderror(err) 15819 } 15820} 15821 15822// UCOMISS: Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS. 15823// 15824// Forms: 15825// 15826// UCOMISS xmm xmm 15827// UCOMISS m32 xmm 15828// Construct and append a UCOMISS instruction to the active function. 15829// Operates on the global context. 15830func UCOMISS(mx, x operand.Op) { ctx.UCOMISS(mx, x) } 15831 15832// UD2: Undefined Instruction. 15833// 15834// Forms: 15835// 15836// UD2 15837// Construct and append a UD2 instruction to the active function. 15838func (c *Context) UD2() { 15839 if inst, err := x86.UD2(); err == nil { 15840 c.Instruction(inst) 15841 } else { 15842 c.adderror(err) 15843 } 15844} 15845 15846// UD2: Undefined Instruction. 15847// 15848// Forms: 15849// 15850// UD2 15851// Construct and append a UD2 instruction to the active function. 15852// Operates on the global context. 15853func UD2() { ctx.UD2() } 15854 15855// UNPCKHPD: Unpack and Interleave High Packed Double-Precision Floating-Point Values. 15856// 15857// Forms: 15858// 15859// UNPCKHPD xmm xmm 15860// UNPCKHPD m128 xmm 15861// Construct and append a UNPCKHPD instruction to the active function. 15862func (c *Context) UNPCKHPD(mx, x operand.Op) { 15863 if inst, err := x86.UNPCKHPD(mx, x); err == nil { 15864 c.Instruction(inst) 15865 } else { 15866 c.adderror(err) 15867 } 15868} 15869 15870// UNPCKHPD: Unpack and Interleave High Packed Double-Precision Floating-Point Values. 15871// 15872// Forms: 15873// 15874// UNPCKHPD xmm xmm 15875// UNPCKHPD m128 xmm 15876// Construct and append a UNPCKHPD instruction to the active function. 15877// Operates on the global context. 15878func UNPCKHPD(mx, x operand.Op) { ctx.UNPCKHPD(mx, x) } 15879 15880// UNPCKHPS: Unpack and Interleave High Packed Single-Precision Floating-Point Values. 15881// 15882// Forms: 15883// 15884// UNPCKHPS xmm xmm 15885// UNPCKHPS m128 xmm 15886// Construct and append a UNPCKHPS instruction to the active function. 15887func (c *Context) UNPCKHPS(mx, x operand.Op) { 15888 if inst, err := x86.UNPCKHPS(mx, x); err == nil { 15889 c.Instruction(inst) 15890 } else { 15891 c.adderror(err) 15892 } 15893} 15894 15895// UNPCKHPS: Unpack and Interleave High Packed Single-Precision Floating-Point Values. 15896// 15897// Forms: 15898// 15899// UNPCKHPS xmm xmm 15900// UNPCKHPS m128 xmm 15901// Construct and append a UNPCKHPS instruction to the active function. 15902// Operates on the global context. 15903func UNPCKHPS(mx, x operand.Op) { ctx.UNPCKHPS(mx, x) } 15904 15905// UNPCKLPD: Unpack and Interleave Low Packed Double-Precision Floating-Point Values. 15906// 15907// Forms: 15908// 15909// UNPCKLPD xmm xmm 15910// UNPCKLPD m128 xmm 15911// Construct and append a UNPCKLPD instruction to the active function. 15912func (c *Context) UNPCKLPD(mx, x operand.Op) { 15913 if inst, err := x86.UNPCKLPD(mx, x); err == nil { 15914 c.Instruction(inst) 15915 } else { 15916 c.adderror(err) 15917 } 15918} 15919 15920// UNPCKLPD: Unpack and Interleave Low Packed Double-Precision Floating-Point Values. 15921// 15922// Forms: 15923// 15924// UNPCKLPD xmm xmm 15925// UNPCKLPD m128 xmm 15926// Construct and append a UNPCKLPD instruction to the active function. 15927// Operates on the global context. 15928func UNPCKLPD(mx, x operand.Op) { ctx.UNPCKLPD(mx, x) } 15929 15930// UNPCKLPS: Unpack and Interleave Low Packed Single-Precision Floating-Point Values. 15931// 15932// Forms: 15933// 15934// UNPCKLPS xmm xmm 15935// UNPCKLPS m128 xmm 15936// Construct and append a UNPCKLPS instruction to the active function. 15937func (c *Context) UNPCKLPS(mx, x operand.Op) { 15938 if inst, err := x86.UNPCKLPS(mx, x); err == nil { 15939 c.Instruction(inst) 15940 } else { 15941 c.adderror(err) 15942 } 15943} 15944 15945// UNPCKLPS: Unpack and Interleave Low Packed Single-Precision Floating-Point Values. 15946// 15947// Forms: 15948// 15949// UNPCKLPS xmm xmm 15950// UNPCKLPS m128 xmm 15951// Construct and append a UNPCKLPS instruction to the active function. 15952// Operates on the global context. 15953func UNPCKLPS(mx, x operand.Op) { ctx.UNPCKLPS(mx, x) } 15954 15955// VADDPD: Add Packed Double-Precision Floating-Point Values. 15956// 15957// Forms: 15958// 15959// VADDPD xmm xmm xmm 15960// VADDPD m128 xmm xmm 15961// VADDPD ymm ymm ymm 15962// VADDPD m256 ymm ymm 15963// Construct and append a VADDPD instruction to the active function. 15964func (c *Context) VADDPD(mxy, xy, xy1 operand.Op) { 15965 if inst, err := x86.VADDPD(mxy, xy, xy1); err == nil { 15966 c.Instruction(inst) 15967 } else { 15968 c.adderror(err) 15969 } 15970} 15971 15972// VADDPD: Add Packed Double-Precision Floating-Point Values. 15973// 15974// Forms: 15975// 15976// VADDPD xmm xmm xmm 15977// VADDPD m128 xmm xmm 15978// VADDPD ymm ymm ymm 15979// VADDPD m256 ymm ymm 15980// Construct and append a VADDPD instruction to the active function. 15981// Operates on the global context. 15982func VADDPD(mxy, xy, xy1 operand.Op) { ctx.VADDPD(mxy, xy, xy1) } 15983 15984// VADDPS: Add Packed Single-Precision Floating-Point Values. 15985// 15986// Forms: 15987// 15988// VADDPS xmm xmm xmm 15989// VADDPS m128 xmm xmm 15990// VADDPS ymm ymm ymm 15991// VADDPS m256 ymm ymm 15992// Construct and append a VADDPS instruction to the active function. 15993func (c *Context) VADDPS(mxy, xy, xy1 operand.Op) { 15994 if inst, err := x86.VADDPS(mxy, xy, xy1); err == nil { 15995 c.Instruction(inst) 15996 } else { 15997 c.adderror(err) 15998 } 15999} 16000 16001// VADDPS: Add Packed Single-Precision Floating-Point Values. 16002// 16003// Forms: 16004// 16005// VADDPS xmm xmm xmm 16006// VADDPS m128 xmm xmm 16007// VADDPS ymm ymm ymm 16008// VADDPS m256 ymm ymm 16009// Construct and append a VADDPS instruction to the active function. 16010// Operates on the global context. 16011func VADDPS(mxy, xy, xy1 operand.Op) { ctx.VADDPS(mxy, xy, xy1) } 16012 16013// VADDSD: Add Scalar Double-Precision Floating-Point Values. 16014// 16015// Forms: 16016// 16017// VADDSD xmm xmm xmm 16018// VADDSD m64 xmm xmm 16019// Construct and append a VADDSD instruction to the active function. 16020func (c *Context) VADDSD(mx, x, x1 operand.Op) { 16021 if inst, err := x86.VADDSD(mx, x, x1); err == nil { 16022 c.Instruction(inst) 16023 } else { 16024 c.adderror(err) 16025 } 16026} 16027 16028// VADDSD: Add Scalar Double-Precision Floating-Point Values. 16029// 16030// Forms: 16031// 16032// VADDSD xmm xmm xmm 16033// VADDSD m64 xmm xmm 16034// Construct and append a VADDSD instruction to the active function. 16035// Operates on the global context. 16036func VADDSD(mx, x, x1 operand.Op) { ctx.VADDSD(mx, x, x1) } 16037 16038// VADDSS: Add Scalar Single-Precision Floating-Point Values. 16039// 16040// Forms: 16041// 16042// VADDSS xmm xmm xmm 16043// VADDSS m32 xmm xmm 16044// Construct and append a VADDSS instruction to the active function. 16045func (c *Context) VADDSS(mx, x, x1 operand.Op) { 16046 if inst, err := x86.VADDSS(mx, x, x1); err == nil { 16047 c.Instruction(inst) 16048 } else { 16049 c.adderror(err) 16050 } 16051} 16052 16053// VADDSS: Add Scalar Single-Precision Floating-Point Values. 16054// 16055// Forms: 16056// 16057// VADDSS xmm xmm xmm 16058// VADDSS m32 xmm xmm 16059// Construct and append a VADDSS instruction to the active function. 16060// Operates on the global context. 16061func VADDSS(mx, x, x1 operand.Op) { ctx.VADDSS(mx, x, x1) } 16062 16063// VADDSUBPD: Packed Double-FP Add/Subtract. 16064// 16065// Forms: 16066// 16067// VADDSUBPD xmm xmm xmm 16068// VADDSUBPD m128 xmm xmm 16069// VADDSUBPD ymm ymm ymm 16070// VADDSUBPD m256 ymm ymm 16071// Construct and append a VADDSUBPD instruction to the active function. 16072func (c *Context) VADDSUBPD(mxy, xy, xy1 operand.Op) { 16073 if inst, err := x86.VADDSUBPD(mxy, xy, xy1); err == nil { 16074 c.Instruction(inst) 16075 } else { 16076 c.adderror(err) 16077 } 16078} 16079 16080// VADDSUBPD: Packed Double-FP Add/Subtract. 16081// 16082// Forms: 16083// 16084// VADDSUBPD xmm xmm xmm 16085// VADDSUBPD m128 xmm xmm 16086// VADDSUBPD ymm ymm ymm 16087// VADDSUBPD m256 ymm ymm 16088// Construct and append a VADDSUBPD instruction to the active function. 16089// Operates on the global context. 16090func VADDSUBPD(mxy, xy, xy1 operand.Op) { ctx.VADDSUBPD(mxy, xy, xy1) } 16091 16092// VADDSUBPS: Packed Single-FP Add/Subtract. 16093// 16094// Forms: 16095// 16096// VADDSUBPS xmm xmm xmm 16097// VADDSUBPS m128 xmm xmm 16098// VADDSUBPS ymm ymm ymm 16099// VADDSUBPS m256 ymm ymm 16100// Construct and append a VADDSUBPS instruction to the active function. 16101func (c *Context) VADDSUBPS(mxy, xy, xy1 operand.Op) { 16102 if inst, err := x86.VADDSUBPS(mxy, xy, xy1); err == nil { 16103 c.Instruction(inst) 16104 } else { 16105 c.adderror(err) 16106 } 16107} 16108 16109// VADDSUBPS: Packed Single-FP Add/Subtract. 16110// 16111// Forms: 16112// 16113// VADDSUBPS xmm xmm xmm 16114// VADDSUBPS m128 xmm xmm 16115// VADDSUBPS ymm ymm ymm 16116// VADDSUBPS m256 ymm ymm 16117// Construct and append a VADDSUBPS instruction to the active function. 16118// Operates on the global context. 16119func VADDSUBPS(mxy, xy, xy1 operand.Op) { ctx.VADDSUBPS(mxy, xy, xy1) } 16120 16121// VAESDEC: Perform One Round of an AES Decryption Flow. 16122// 16123// Forms: 16124// 16125// VAESDEC xmm xmm xmm 16126// VAESDEC m128 xmm xmm 16127// Construct and append a VAESDEC instruction to the active function. 16128func (c *Context) VAESDEC(mx, x, x1 operand.Op) { 16129 if inst, err := x86.VAESDEC(mx, x, x1); err == nil { 16130 c.Instruction(inst) 16131 } else { 16132 c.adderror(err) 16133 } 16134} 16135 16136// VAESDEC: Perform One Round of an AES Decryption Flow. 16137// 16138// Forms: 16139// 16140// VAESDEC xmm xmm xmm 16141// VAESDEC m128 xmm xmm 16142// Construct and append a VAESDEC instruction to the active function. 16143// Operates on the global context. 16144func VAESDEC(mx, x, x1 operand.Op) { ctx.VAESDEC(mx, x, x1) } 16145 16146// VAESDECLAST: Perform Last Round of an AES Decryption Flow. 16147// 16148// Forms: 16149// 16150// VAESDECLAST xmm xmm xmm 16151// VAESDECLAST m128 xmm xmm 16152// Construct and append a VAESDECLAST instruction to the active function. 16153func (c *Context) VAESDECLAST(mx, x, x1 operand.Op) { 16154 if inst, err := x86.VAESDECLAST(mx, x, x1); err == nil { 16155 c.Instruction(inst) 16156 } else { 16157 c.adderror(err) 16158 } 16159} 16160 16161// VAESDECLAST: Perform Last Round of an AES Decryption Flow. 16162// 16163// Forms: 16164// 16165// VAESDECLAST xmm xmm xmm 16166// VAESDECLAST m128 xmm xmm 16167// Construct and append a VAESDECLAST instruction to the active function. 16168// Operates on the global context. 16169func VAESDECLAST(mx, x, x1 operand.Op) { ctx.VAESDECLAST(mx, x, x1) } 16170 16171// VAESENC: Perform One Round of an AES Encryption Flow. 16172// 16173// Forms: 16174// 16175// VAESENC xmm xmm xmm 16176// VAESENC m128 xmm xmm 16177// Construct and append a VAESENC instruction to the active function. 16178func (c *Context) VAESENC(mx, x, x1 operand.Op) { 16179 if inst, err := x86.VAESENC(mx, x, x1); err == nil { 16180 c.Instruction(inst) 16181 } else { 16182 c.adderror(err) 16183 } 16184} 16185 16186// VAESENC: Perform One Round of an AES Encryption Flow. 16187// 16188// Forms: 16189// 16190// VAESENC xmm xmm xmm 16191// VAESENC m128 xmm xmm 16192// Construct and append a VAESENC instruction to the active function. 16193// Operates on the global context. 16194func VAESENC(mx, x, x1 operand.Op) { ctx.VAESENC(mx, x, x1) } 16195 16196// VAESENCLAST: Perform Last Round of an AES Encryption Flow. 16197// 16198// Forms: 16199// 16200// VAESENCLAST xmm xmm xmm 16201// VAESENCLAST m128 xmm xmm 16202// Construct and append a VAESENCLAST instruction to the active function. 16203func (c *Context) VAESENCLAST(mx, x, x1 operand.Op) { 16204 if inst, err := x86.VAESENCLAST(mx, x, x1); err == nil { 16205 c.Instruction(inst) 16206 } else { 16207 c.adderror(err) 16208 } 16209} 16210 16211// VAESENCLAST: Perform Last Round of an AES Encryption Flow. 16212// 16213// Forms: 16214// 16215// VAESENCLAST xmm xmm xmm 16216// VAESENCLAST m128 xmm xmm 16217// Construct and append a VAESENCLAST instruction to the active function. 16218// Operates on the global context. 16219func VAESENCLAST(mx, x, x1 operand.Op) { ctx.VAESENCLAST(mx, x, x1) } 16220 16221// VAESIMC: Perform the AES InvMixColumn Transformation. 16222// 16223// Forms: 16224// 16225// VAESIMC xmm xmm 16226// VAESIMC m128 xmm 16227// Construct and append a VAESIMC instruction to the active function. 16228func (c *Context) VAESIMC(mx, x operand.Op) { 16229 if inst, err := x86.VAESIMC(mx, x); err == nil { 16230 c.Instruction(inst) 16231 } else { 16232 c.adderror(err) 16233 } 16234} 16235 16236// VAESIMC: Perform the AES InvMixColumn Transformation. 16237// 16238// Forms: 16239// 16240// VAESIMC xmm xmm 16241// VAESIMC m128 xmm 16242// Construct and append a VAESIMC instruction to the active function. 16243// Operates on the global context. 16244func VAESIMC(mx, x operand.Op) { ctx.VAESIMC(mx, x) } 16245 16246// VAESKEYGENASSIST: AES Round Key Generation Assist. 16247// 16248// Forms: 16249// 16250// VAESKEYGENASSIST imm8 xmm xmm 16251// VAESKEYGENASSIST imm8 m128 xmm 16252// Construct and append a VAESKEYGENASSIST instruction to the active function. 16253func (c *Context) VAESKEYGENASSIST(i, mx, x operand.Op) { 16254 if inst, err := x86.VAESKEYGENASSIST(i, mx, x); err == nil { 16255 c.Instruction(inst) 16256 } else { 16257 c.adderror(err) 16258 } 16259} 16260 16261// VAESKEYGENASSIST: AES Round Key Generation Assist. 16262// 16263// Forms: 16264// 16265// VAESKEYGENASSIST imm8 xmm xmm 16266// VAESKEYGENASSIST imm8 m128 xmm 16267// Construct and append a VAESKEYGENASSIST instruction to the active function. 16268// Operates on the global context. 16269func VAESKEYGENASSIST(i, mx, x operand.Op) { ctx.VAESKEYGENASSIST(i, mx, x) } 16270 16271// VANDNPD: Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values. 16272// 16273// Forms: 16274// 16275// VANDNPD xmm xmm xmm 16276// VANDNPD m128 xmm xmm 16277// VANDNPD ymm ymm ymm 16278// VANDNPD m256 ymm ymm 16279// Construct and append a VANDNPD instruction to the active function. 16280func (c *Context) VANDNPD(mxy, xy, xy1 operand.Op) { 16281 if inst, err := x86.VANDNPD(mxy, xy, xy1); err == nil { 16282 c.Instruction(inst) 16283 } else { 16284 c.adderror(err) 16285 } 16286} 16287 16288// VANDNPD: Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values. 16289// 16290// Forms: 16291// 16292// VANDNPD xmm xmm xmm 16293// VANDNPD m128 xmm xmm 16294// VANDNPD ymm ymm ymm 16295// VANDNPD m256 ymm ymm 16296// Construct and append a VANDNPD instruction to the active function. 16297// Operates on the global context. 16298func VANDNPD(mxy, xy, xy1 operand.Op) { ctx.VANDNPD(mxy, xy, xy1) } 16299 16300// VANDNPS: Bitwise Logical AND NOT of Packed Single-Precision Floating-Point Values. 16301// 16302// Forms: 16303// 16304// VANDNPS xmm xmm xmm 16305// VANDNPS m128 xmm xmm 16306// VANDNPS ymm ymm ymm 16307// VANDNPS m256 ymm ymm 16308// Construct and append a VANDNPS instruction to the active function. 16309func (c *Context) VANDNPS(mxy, xy, xy1 operand.Op) { 16310 if inst, err := x86.VANDNPS(mxy, xy, xy1); err == nil { 16311 c.Instruction(inst) 16312 } else { 16313 c.adderror(err) 16314 } 16315} 16316 16317// VANDNPS: Bitwise Logical AND NOT of Packed Single-Precision Floating-Point Values. 16318// 16319// Forms: 16320// 16321// VANDNPS xmm xmm xmm 16322// VANDNPS m128 xmm xmm 16323// VANDNPS ymm ymm ymm 16324// VANDNPS m256 ymm ymm 16325// Construct and append a VANDNPS instruction to the active function. 16326// Operates on the global context. 16327func VANDNPS(mxy, xy, xy1 operand.Op) { ctx.VANDNPS(mxy, xy, xy1) } 16328 16329// VANDPD: Bitwise Logical AND of Packed Double-Precision Floating-Point Values. 16330// 16331// Forms: 16332// 16333// VANDPD xmm xmm xmm 16334// VANDPD m128 xmm xmm 16335// VANDPD ymm ymm ymm 16336// VANDPD m256 ymm ymm 16337// Construct and append a VANDPD instruction to the active function. 16338func (c *Context) VANDPD(mxy, xy, xy1 operand.Op) { 16339 if inst, err := x86.VANDPD(mxy, xy, xy1); err == nil { 16340 c.Instruction(inst) 16341 } else { 16342 c.adderror(err) 16343 } 16344} 16345 16346// VANDPD: Bitwise Logical AND of Packed Double-Precision Floating-Point Values. 16347// 16348// Forms: 16349// 16350// VANDPD xmm xmm xmm 16351// VANDPD m128 xmm xmm 16352// VANDPD ymm ymm ymm 16353// VANDPD m256 ymm ymm 16354// Construct and append a VANDPD instruction to the active function. 16355// Operates on the global context. 16356func VANDPD(mxy, xy, xy1 operand.Op) { ctx.VANDPD(mxy, xy, xy1) } 16357 16358// VANDPS: Bitwise Logical AND of Packed Single-Precision Floating-Point Values. 16359// 16360// Forms: 16361// 16362// VANDPS xmm xmm xmm 16363// VANDPS m128 xmm xmm 16364// VANDPS ymm ymm ymm 16365// VANDPS m256 ymm ymm 16366// Construct and append a VANDPS instruction to the active function. 16367func (c *Context) VANDPS(mxy, xy, xy1 operand.Op) { 16368 if inst, err := x86.VANDPS(mxy, xy, xy1); err == nil { 16369 c.Instruction(inst) 16370 } else { 16371 c.adderror(err) 16372 } 16373} 16374 16375// VANDPS: Bitwise Logical AND of Packed Single-Precision Floating-Point Values. 16376// 16377// Forms: 16378// 16379// VANDPS xmm xmm xmm 16380// VANDPS m128 xmm xmm 16381// VANDPS ymm ymm ymm 16382// VANDPS m256 ymm ymm 16383// Construct and append a VANDPS instruction to the active function. 16384// Operates on the global context. 16385func VANDPS(mxy, xy, xy1 operand.Op) { ctx.VANDPS(mxy, xy, xy1) } 16386 16387// VBLENDPD: Blend Packed Double Precision Floating-Point Values. 16388// 16389// Forms: 16390// 16391// VBLENDPD imm8 xmm xmm xmm 16392// VBLENDPD imm8 m128 xmm xmm 16393// VBLENDPD imm8 ymm ymm ymm 16394// VBLENDPD imm8 m256 ymm ymm 16395// Construct and append a VBLENDPD instruction to the active function. 16396func (c *Context) VBLENDPD(i, mxy, xy, xy1 operand.Op) { 16397 if inst, err := x86.VBLENDPD(i, mxy, xy, xy1); err == nil { 16398 c.Instruction(inst) 16399 } else { 16400 c.adderror(err) 16401 } 16402} 16403 16404// VBLENDPD: Blend Packed Double Precision Floating-Point Values. 16405// 16406// Forms: 16407// 16408// VBLENDPD imm8 xmm xmm xmm 16409// VBLENDPD imm8 m128 xmm xmm 16410// VBLENDPD imm8 ymm ymm ymm 16411// VBLENDPD imm8 m256 ymm ymm 16412// Construct and append a VBLENDPD instruction to the active function. 16413// Operates on the global context. 16414func VBLENDPD(i, mxy, xy, xy1 operand.Op) { ctx.VBLENDPD(i, mxy, xy, xy1) } 16415 16416// VBLENDPS: Blend Packed Single Precision Floating-Point Values. 16417// 16418// Forms: 16419// 16420// VBLENDPS imm8 xmm xmm xmm 16421// VBLENDPS imm8 m128 xmm xmm 16422// VBLENDPS imm8 ymm ymm ymm 16423// VBLENDPS imm8 m256 ymm ymm 16424// Construct and append a VBLENDPS instruction to the active function. 16425func (c *Context) VBLENDPS(i, mxy, xy, xy1 operand.Op) { 16426 if inst, err := x86.VBLENDPS(i, mxy, xy, xy1); err == nil { 16427 c.Instruction(inst) 16428 } else { 16429 c.adderror(err) 16430 } 16431} 16432 16433// VBLENDPS: Blend Packed Single Precision Floating-Point Values. 16434// 16435// Forms: 16436// 16437// VBLENDPS imm8 xmm xmm xmm 16438// VBLENDPS imm8 m128 xmm xmm 16439// VBLENDPS imm8 ymm ymm ymm 16440// VBLENDPS imm8 m256 ymm ymm 16441// Construct and append a VBLENDPS instruction to the active function. 16442// Operates on the global context. 16443func VBLENDPS(i, mxy, xy, xy1 operand.Op) { ctx.VBLENDPS(i, mxy, xy, xy1) } 16444 16445// VBLENDVPD: Variable Blend Packed Double Precision Floating-Point Values. 16446// 16447// Forms: 16448// 16449// VBLENDVPD xmm xmm xmm xmm 16450// VBLENDVPD xmm m128 xmm xmm 16451// VBLENDVPD ymm ymm ymm ymm 16452// VBLENDVPD ymm m256 ymm ymm 16453// Construct and append a VBLENDVPD instruction to the active function. 16454func (c *Context) VBLENDVPD(xy, mxy, xy1, xy2 operand.Op) { 16455 if inst, err := x86.VBLENDVPD(xy, mxy, xy1, xy2); err == nil { 16456 c.Instruction(inst) 16457 } else { 16458 c.adderror(err) 16459 } 16460} 16461 16462// VBLENDVPD: Variable Blend Packed Double Precision Floating-Point Values. 16463// 16464// Forms: 16465// 16466// VBLENDVPD xmm xmm xmm xmm 16467// VBLENDVPD xmm m128 xmm xmm 16468// VBLENDVPD ymm ymm ymm ymm 16469// VBLENDVPD ymm m256 ymm ymm 16470// Construct and append a VBLENDVPD instruction to the active function. 16471// Operates on the global context. 16472func VBLENDVPD(xy, mxy, xy1, xy2 operand.Op) { ctx.VBLENDVPD(xy, mxy, xy1, xy2) } 16473 16474// VBLENDVPS: Variable Blend Packed Single Precision Floating-Point Values. 16475// 16476// Forms: 16477// 16478// VBLENDVPS xmm xmm xmm xmm 16479// VBLENDVPS xmm m128 xmm xmm 16480// VBLENDVPS ymm ymm ymm ymm 16481// VBLENDVPS ymm m256 ymm ymm 16482// Construct and append a VBLENDVPS instruction to the active function. 16483func (c *Context) VBLENDVPS(xy, mxy, xy1, xy2 operand.Op) { 16484 if inst, err := x86.VBLENDVPS(xy, mxy, xy1, xy2); err == nil { 16485 c.Instruction(inst) 16486 } else { 16487 c.adderror(err) 16488 } 16489} 16490 16491// VBLENDVPS: Variable Blend Packed Single Precision Floating-Point Values. 16492// 16493// Forms: 16494// 16495// VBLENDVPS xmm xmm xmm xmm 16496// VBLENDVPS xmm m128 xmm xmm 16497// VBLENDVPS ymm ymm ymm ymm 16498// VBLENDVPS ymm m256 ymm ymm 16499// Construct and append a VBLENDVPS instruction to the active function. 16500// Operates on the global context. 16501func VBLENDVPS(xy, mxy, xy1, xy2 operand.Op) { ctx.VBLENDVPS(xy, mxy, xy1, xy2) } 16502 16503// VBROADCASTF128: Broadcast 128 Bit of Floating-Point Data. 16504// 16505// Forms: 16506// 16507// VBROADCASTF128 m128 ymm 16508// Construct and append a VBROADCASTF128 instruction to the active function. 16509func (c *Context) VBROADCASTF128(m, y operand.Op) { 16510 if inst, err := x86.VBROADCASTF128(m, y); err == nil { 16511 c.Instruction(inst) 16512 } else { 16513 c.adderror(err) 16514 } 16515} 16516 16517// VBROADCASTF128: Broadcast 128 Bit of Floating-Point Data. 16518// 16519// Forms: 16520// 16521// VBROADCASTF128 m128 ymm 16522// Construct and append a VBROADCASTF128 instruction to the active function. 16523// Operates on the global context. 16524func VBROADCASTF128(m, y operand.Op) { ctx.VBROADCASTF128(m, y) } 16525 16526// VBROADCASTI128: Broadcast 128 Bits of Integer Data. 16527// 16528// Forms: 16529// 16530// VBROADCASTI128 m128 ymm 16531// Construct and append a VBROADCASTI128 instruction to the active function. 16532func (c *Context) VBROADCASTI128(m, y operand.Op) { 16533 if inst, err := x86.VBROADCASTI128(m, y); err == nil { 16534 c.Instruction(inst) 16535 } else { 16536 c.adderror(err) 16537 } 16538} 16539 16540// VBROADCASTI128: Broadcast 128 Bits of Integer Data. 16541// 16542// Forms: 16543// 16544// VBROADCASTI128 m128 ymm 16545// Construct and append a VBROADCASTI128 instruction to the active function. 16546// Operates on the global context. 16547func VBROADCASTI128(m, y operand.Op) { ctx.VBROADCASTI128(m, y) } 16548 16549// VBROADCASTSD: Broadcast Double-Precision Floating-Point Element. 16550// 16551// Forms: 16552// 16553// VBROADCASTSD xmm ymm 16554// VBROADCASTSD m64 ymm 16555// Construct and append a VBROADCASTSD instruction to the active function. 16556func (c *Context) VBROADCASTSD(mx, y operand.Op) { 16557 if inst, err := x86.VBROADCASTSD(mx, y); err == nil { 16558 c.Instruction(inst) 16559 } else { 16560 c.adderror(err) 16561 } 16562} 16563 16564// VBROADCASTSD: Broadcast Double-Precision Floating-Point Element. 16565// 16566// Forms: 16567// 16568// VBROADCASTSD xmm ymm 16569// VBROADCASTSD m64 ymm 16570// Construct and append a VBROADCASTSD instruction to the active function. 16571// Operates on the global context. 16572func VBROADCASTSD(mx, y operand.Op) { ctx.VBROADCASTSD(mx, y) } 16573 16574// VBROADCASTSS: Broadcast Single-Precision Floating-Point Element. 16575// 16576// Forms: 16577// 16578// VBROADCASTSS xmm xmm 16579// VBROADCASTSS m32 xmm 16580// VBROADCASTSS xmm ymm 16581// VBROADCASTSS m32 ymm 16582// Construct and append a VBROADCASTSS instruction to the active function. 16583func (c *Context) VBROADCASTSS(mx, xy operand.Op) { 16584 if inst, err := x86.VBROADCASTSS(mx, xy); err == nil { 16585 c.Instruction(inst) 16586 } else { 16587 c.adderror(err) 16588 } 16589} 16590 16591// VBROADCASTSS: Broadcast Single-Precision Floating-Point Element. 16592// 16593// Forms: 16594// 16595// VBROADCASTSS xmm xmm 16596// VBROADCASTSS m32 xmm 16597// VBROADCASTSS xmm ymm 16598// VBROADCASTSS m32 ymm 16599// Construct and append a VBROADCASTSS instruction to the active function. 16600// Operates on the global context. 16601func VBROADCASTSS(mx, xy operand.Op) { ctx.VBROADCASTSS(mx, xy) } 16602 16603// VCMPPD: Compare Packed Double-Precision Floating-Point Values. 16604// 16605// Forms: 16606// 16607// VCMPPD imm8 xmm xmm xmm 16608// VCMPPD imm8 m128 xmm xmm 16609// VCMPPD imm8 ymm ymm ymm 16610// VCMPPD imm8 m256 ymm ymm 16611// Construct and append a VCMPPD instruction to the active function. 16612func (c *Context) VCMPPD(i, mxy, xy, xy1 operand.Op) { 16613 if inst, err := x86.VCMPPD(i, mxy, xy, xy1); err == nil { 16614 c.Instruction(inst) 16615 } else { 16616 c.adderror(err) 16617 } 16618} 16619 16620// VCMPPD: Compare Packed Double-Precision Floating-Point Values. 16621// 16622// Forms: 16623// 16624// VCMPPD imm8 xmm xmm xmm 16625// VCMPPD imm8 m128 xmm xmm 16626// VCMPPD imm8 ymm ymm ymm 16627// VCMPPD imm8 m256 ymm ymm 16628// Construct and append a VCMPPD instruction to the active function. 16629// Operates on the global context. 16630func VCMPPD(i, mxy, xy, xy1 operand.Op) { ctx.VCMPPD(i, mxy, xy, xy1) } 16631 16632// VCMPPS: Compare Packed Single-Precision Floating-Point Values. 16633// 16634// Forms: 16635// 16636// VCMPPS imm8 xmm xmm xmm 16637// VCMPPS imm8 m128 xmm xmm 16638// VCMPPS imm8 ymm ymm ymm 16639// VCMPPS imm8 m256 ymm ymm 16640// Construct and append a VCMPPS instruction to the active function. 16641func (c *Context) VCMPPS(i, mxy, xy, xy1 operand.Op) { 16642 if inst, err := x86.VCMPPS(i, mxy, xy, xy1); err == nil { 16643 c.Instruction(inst) 16644 } else { 16645 c.adderror(err) 16646 } 16647} 16648 16649// VCMPPS: Compare Packed Single-Precision Floating-Point Values. 16650// 16651// Forms: 16652// 16653// VCMPPS imm8 xmm xmm xmm 16654// VCMPPS imm8 m128 xmm xmm 16655// VCMPPS imm8 ymm ymm ymm 16656// VCMPPS imm8 m256 ymm ymm 16657// Construct and append a VCMPPS instruction to the active function. 16658// Operates on the global context. 16659func VCMPPS(i, mxy, xy, xy1 operand.Op) { ctx.VCMPPS(i, mxy, xy, xy1) } 16660 16661// VCMPSD: Compare Scalar Double-Precision Floating-Point Values. 16662// 16663// Forms: 16664// 16665// VCMPSD imm8 xmm xmm xmm 16666// VCMPSD imm8 m64 xmm xmm 16667// Construct and append a VCMPSD instruction to the active function. 16668func (c *Context) VCMPSD(i, mx, x, x1 operand.Op) { 16669 if inst, err := x86.VCMPSD(i, mx, x, x1); err == nil { 16670 c.Instruction(inst) 16671 } else { 16672 c.adderror(err) 16673 } 16674} 16675 16676// VCMPSD: Compare Scalar Double-Precision Floating-Point Values. 16677// 16678// Forms: 16679// 16680// VCMPSD imm8 xmm xmm xmm 16681// VCMPSD imm8 m64 xmm xmm 16682// Construct and append a VCMPSD instruction to the active function. 16683// Operates on the global context. 16684func VCMPSD(i, mx, x, x1 operand.Op) { ctx.VCMPSD(i, mx, x, x1) } 16685 16686// VCMPSS: Compare Scalar Single-Precision Floating-Point Values. 16687// 16688// Forms: 16689// 16690// VCMPSS imm8 xmm xmm xmm 16691// VCMPSS imm8 m32 xmm xmm 16692// Construct and append a VCMPSS instruction to the active function. 16693func (c *Context) VCMPSS(i, mx, x, x1 operand.Op) { 16694 if inst, err := x86.VCMPSS(i, mx, x, x1); err == nil { 16695 c.Instruction(inst) 16696 } else { 16697 c.adderror(err) 16698 } 16699} 16700 16701// VCMPSS: Compare Scalar Single-Precision Floating-Point Values. 16702// 16703// Forms: 16704// 16705// VCMPSS imm8 xmm xmm xmm 16706// VCMPSS imm8 m32 xmm xmm 16707// Construct and append a VCMPSS instruction to the active function. 16708// Operates on the global context. 16709func VCMPSS(i, mx, x, x1 operand.Op) { ctx.VCMPSS(i, mx, x, x1) } 16710 16711// VCOMISD: Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS. 16712// 16713// Forms: 16714// 16715// VCOMISD xmm xmm 16716// VCOMISD m64 xmm 16717// Construct and append a VCOMISD instruction to the active function. 16718func (c *Context) VCOMISD(mx, x operand.Op) { 16719 if inst, err := x86.VCOMISD(mx, x); err == nil { 16720 c.Instruction(inst) 16721 } else { 16722 c.adderror(err) 16723 } 16724} 16725 16726// VCOMISD: Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS. 16727// 16728// Forms: 16729// 16730// VCOMISD xmm xmm 16731// VCOMISD m64 xmm 16732// Construct and append a VCOMISD instruction to the active function. 16733// Operates on the global context. 16734func VCOMISD(mx, x operand.Op) { ctx.VCOMISD(mx, x) } 16735 16736// VCOMISS: Compare Scalar Ordered Single-Precision Floating-Point Values and Set EFLAGS. 16737// 16738// Forms: 16739// 16740// VCOMISS xmm xmm 16741// VCOMISS m32 xmm 16742// Construct and append a VCOMISS instruction to the active function. 16743func (c *Context) VCOMISS(mx, x operand.Op) { 16744 if inst, err := x86.VCOMISS(mx, x); err == nil { 16745 c.Instruction(inst) 16746 } else { 16747 c.adderror(err) 16748 } 16749} 16750 16751// VCOMISS: Compare Scalar Ordered Single-Precision Floating-Point Values and Set EFLAGS. 16752// 16753// Forms: 16754// 16755// VCOMISS xmm xmm 16756// VCOMISS m32 xmm 16757// Construct and append a VCOMISS instruction to the active function. 16758// Operates on the global context. 16759func VCOMISS(mx, x operand.Op) { ctx.VCOMISS(mx, x) } 16760 16761// VCVTDQ2PD: Convert Packed Dword Integers to Packed Double-Precision FP Values. 16762// 16763// Forms: 16764// 16765// VCVTDQ2PD xmm xmm 16766// VCVTDQ2PD m64 xmm 16767// VCVTDQ2PD xmm ymm 16768// VCVTDQ2PD m128 ymm 16769// Construct and append a VCVTDQ2PD instruction to the active function. 16770func (c *Context) VCVTDQ2PD(mx, xy operand.Op) { 16771 if inst, err := x86.VCVTDQ2PD(mx, xy); err == nil { 16772 c.Instruction(inst) 16773 } else { 16774 c.adderror(err) 16775 } 16776} 16777 16778// VCVTDQ2PD: Convert Packed Dword Integers to Packed Double-Precision FP Values. 16779// 16780// Forms: 16781// 16782// VCVTDQ2PD xmm xmm 16783// VCVTDQ2PD m64 xmm 16784// VCVTDQ2PD xmm ymm 16785// VCVTDQ2PD m128 ymm 16786// Construct and append a VCVTDQ2PD instruction to the active function. 16787// Operates on the global context. 16788func VCVTDQ2PD(mx, xy operand.Op) { ctx.VCVTDQ2PD(mx, xy) } 16789 16790// VCVTDQ2PS: Convert Packed Dword Integers to Packed Single-Precision FP Values. 16791// 16792// Forms: 16793// 16794// VCVTDQ2PS xmm xmm 16795// VCVTDQ2PS m128 xmm 16796// VCVTDQ2PS ymm ymm 16797// VCVTDQ2PS m256 ymm 16798// Construct and append a VCVTDQ2PS instruction to the active function. 16799func (c *Context) VCVTDQ2PS(mxy, xy operand.Op) { 16800 if inst, err := x86.VCVTDQ2PS(mxy, xy); err == nil { 16801 c.Instruction(inst) 16802 } else { 16803 c.adderror(err) 16804 } 16805} 16806 16807// VCVTDQ2PS: Convert Packed Dword Integers to Packed Single-Precision FP Values. 16808// 16809// Forms: 16810// 16811// VCVTDQ2PS xmm xmm 16812// VCVTDQ2PS m128 xmm 16813// VCVTDQ2PS ymm ymm 16814// VCVTDQ2PS m256 ymm 16815// Construct and append a VCVTDQ2PS instruction to the active function. 16816// Operates on the global context. 16817func VCVTDQ2PS(mxy, xy operand.Op) { ctx.VCVTDQ2PS(mxy, xy) } 16818 16819// VCVTPD2DQX: Convert Packed Double-Precision FP Values to Packed Dword Integers. 16820// 16821// Forms: 16822// 16823// VCVTPD2DQX xmm xmm 16824// VCVTPD2DQX m128 xmm 16825// Construct and append a VCVTPD2DQX instruction to the active function. 16826func (c *Context) VCVTPD2DQX(mx, x operand.Op) { 16827 if inst, err := x86.VCVTPD2DQX(mx, x); err == nil { 16828 c.Instruction(inst) 16829 } else { 16830 c.adderror(err) 16831 } 16832} 16833 16834// VCVTPD2DQX: Convert Packed Double-Precision FP Values to Packed Dword Integers. 16835// 16836// Forms: 16837// 16838// VCVTPD2DQX xmm xmm 16839// VCVTPD2DQX m128 xmm 16840// Construct and append a VCVTPD2DQX instruction to the active function. 16841// Operates on the global context. 16842func VCVTPD2DQX(mx, x operand.Op) { ctx.VCVTPD2DQX(mx, x) } 16843 16844// VCVTPD2DQY: Convert Packed Double-Precision FP Values to Packed Dword Integers. 16845// 16846// Forms: 16847// 16848// VCVTPD2DQY ymm xmm 16849// VCVTPD2DQY m256 xmm 16850// Construct and append a VCVTPD2DQY instruction to the active function. 16851func (c *Context) VCVTPD2DQY(my, x operand.Op) { 16852 if inst, err := x86.VCVTPD2DQY(my, x); err == nil { 16853 c.Instruction(inst) 16854 } else { 16855 c.adderror(err) 16856 } 16857} 16858 16859// VCVTPD2DQY: Convert Packed Double-Precision FP Values to Packed Dword Integers. 16860// 16861// Forms: 16862// 16863// VCVTPD2DQY ymm xmm 16864// VCVTPD2DQY m256 xmm 16865// Construct and append a VCVTPD2DQY instruction to the active function. 16866// Operates on the global context. 16867func VCVTPD2DQY(my, x operand.Op) { ctx.VCVTPD2DQY(my, x) } 16868 16869// VCVTPD2PSX: Convert Packed Double-Precision FP Values to Packed Single-Precision FP Values. 16870// 16871// Forms: 16872// 16873// VCVTPD2PSX xmm xmm 16874// VCVTPD2PSX m128 xmm 16875// Construct and append a VCVTPD2PSX instruction to the active function. 16876func (c *Context) VCVTPD2PSX(mx, x operand.Op) { 16877 if inst, err := x86.VCVTPD2PSX(mx, x); err == nil { 16878 c.Instruction(inst) 16879 } else { 16880 c.adderror(err) 16881 } 16882} 16883 16884// VCVTPD2PSX: Convert Packed Double-Precision FP Values to Packed Single-Precision FP Values. 16885// 16886// Forms: 16887// 16888// VCVTPD2PSX xmm xmm 16889// VCVTPD2PSX m128 xmm 16890// Construct and append a VCVTPD2PSX instruction to the active function. 16891// Operates on the global context. 16892func VCVTPD2PSX(mx, x operand.Op) { ctx.VCVTPD2PSX(mx, x) } 16893 16894// VCVTPD2PSY: Convert Packed Double-Precision FP Values to Packed Single-Precision FP Values. 16895// 16896// Forms: 16897// 16898// VCVTPD2PSY ymm xmm 16899// VCVTPD2PSY m256 xmm 16900// Construct and append a VCVTPD2PSY instruction to the active function. 16901func (c *Context) VCVTPD2PSY(my, x operand.Op) { 16902 if inst, err := x86.VCVTPD2PSY(my, x); err == nil { 16903 c.Instruction(inst) 16904 } else { 16905 c.adderror(err) 16906 } 16907} 16908 16909// VCVTPD2PSY: Convert Packed Double-Precision FP Values to Packed Single-Precision FP Values. 16910// 16911// Forms: 16912// 16913// VCVTPD2PSY ymm xmm 16914// VCVTPD2PSY m256 xmm 16915// Construct and append a VCVTPD2PSY instruction to the active function. 16916// Operates on the global context. 16917func VCVTPD2PSY(my, x operand.Op) { ctx.VCVTPD2PSY(my, x) } 16918 16919// VCVTPH2PS: Convert Half-Precision FP Values to Single-Precision FP Values. 16920// 16921// Forms: 16922// 16923// VCVTPH2PS xmm xmm 16924// VCVTPH2PS m64 xmm 16925// VCVTPH2PS xmm ymm 16926// VCVTPH2PS m128 ymm 16927// Construct and append a VCVTPH2PS instruction to the active function. 16928func (c *Context) VCVTPH2PS(mx, xy operand.Op) { 16929 if inst, err := x86.VCVTPH2PS(mx, xy); err == nil { 16930 c.Instruction(inst) 16931 } else { 16932 c.adderror(err) 16933 } 16934} 16935 16936// VCVTPH2PS: Convert Half-Precision FP Values to Single-Precision FP Values. 16937// 16938// Forms: 16939// 16940// VCVTPH2PS xmm xmm 16941// VCVTPH2PS m64 xmm 16942// VCVTPH2PS xmm ymm 16943// VCVTPH2PS m128 ymm 16944// Construct and append a VCVTPH2PS instruction to the active function. 16945// Operates on the global context. 16946func VCVTPH2PS(mx, xy operand.Op) { ctx.VCVTPH2PS(mx, xy) } 16947 16948// VCVTPS2DQ: Convert Packed Single-Precision FP Values to Packed Dword Integers. 16949// 16950// Forms: 16951// 16952// VCVTPS2DQ xmm xmm 16953// VCVTPS2DQ m128 xmm 16954// VCVTPS2DQ ymm ymm 16955// VCVTPS2DQ m256 ymm 16956// Construct and append a VCVTPS2DQ instruction to the active function. 16957func (c *Context) VCVTPS2DQ(mxy, xy operand.Op) { 16958 if inst, err := x86.VCVTPS2DQ(mxy, xy); err == nil { 16959 c.Instruction(inst) 16960 } else { 16961 c.adderror(err) 16962 } 16963} 16964 16965// VCVTPS2DQ: Convert Packed Single-Precision FP Values to Packed Dword Integers. 16966// 16967// Forms: 16968// 16969// VCVTPS2DQ xmm xmm 16970// VCVTPS2DQ m128 xmm 16971// VCVTPS2DQ ymm ymm 16972// VCVTPS2DQ m256 ymm 16973// Construct and append a VCVTPS2DQ instruction to the active function. 16974// Operates on the global context. 16975func VCVTPS2DQ(mxy, xy operand.Op) { ctx.VCVTPS2DQ(mxy, xy) } 16976 16977// VCVTPS2PD: Convert Packed Single-Precision FP Values to Packed Double-Precision FP Values. 16978// 16979// Forms: 16980// 16981// VCVTPS2PD xmm xmm 16982// VCVTPS2PD m64 xmm 16983// VCVTPS2PD xmm ymm 16984// VCVTPS2PD m128 ymm 16985// Construct and append a VCVTPS2PD instruction to the active function. 16986func (c *Context) VCVTPS2PD(mx, xy operand.Op) { 16987 if inst, err := x86.VCVTPS2PD(mx, xy); err == nil { 16988 c.Instruction(inst) 16989 } else { 16990 c.adderror(err) 16991 } 16992} 16993 16994// VCVTPS2PD: Convert Packed Single-Precision FP Values to Packed Double-Precision FP Values. 16995// 16996// Forms: 16997// 16998// VCVTPS2PD xmm xmm 16999// VCVTPS2PD m64 xmm 17000// VCVTPS2PD xmm ymm 17001// VCVTPS2PD m128 ymm 17002// Construct and append a VCVTPS2PD instruction to the active function. 17003// Operates on the global context. 17004func VCVTPS2PD(mx, xy operand.Op) { ctx.VCVTPS2PD(mx, xy) } 17005 17006// VCVTPS2PH: Convert Single-Precision FP value to Half-Precision FP value. 17007// 17008// Forms: 17009// 17010// VCVTPS2PH imm8 xmm xmm 17011// VCVTPS2PH imm8 ymm xmm 17012// VCVTPS2PH imm8 xmm m64 17013// VCVTPS2PH imm8 ymm m128 17014// Construct and append a VCVTPS2PH instruction to the active function. 17015func (c *Context) VCVTPS2PH(i, xy, mx operand.Op) { 17016 if inst, err := x86.VCVTPS2PH(i, xy, mx); err == nil { 17017 c.Instruction(inst) 17018 } else { 17019 c.adderror(err) 17020 } 17021} 17022 17023// VCVTPS2PH: Convert Single-Precision FP value to Half-Precision FP value. 17024// 17025// Forms: 17026// 17027// VCVTPS2PH imm8 xmm xmm 17028// VCVTPS2PH imm8 ymm xmm 17029// VCVTPS2PH imm8 xmm m64 17030// VCVTPS2PH imm8 ymm m128 17031// Construct and append a VCVTPS2PH instruction to the active function. 17032// Operates on the global context. 17033func VCVTPS2PH(i, xy, mx operand.Op) { ctx.VCVTPS2PH(i, xy, mx) } 17034 17035// VCVTSD2SI: Convert Scalar Double-Precision FP Value to Integer. 17036// 17037// Forms: 17038// 17039// VCVTSD2SI xmm r32 17040// VCVTSD2SI m64 r32 17041// Construct and append a VCVTSD2SI instruction to the active function. 17042func (c *Context) VCVTSD2SI(mx, r operand.Op) { 17043 if inst, err := x86.VCVTSD2SI(mx, r); err == nil { 17044 c.Instruction(inst) 17045 } else { 17046 c.adderror(err) 17047 } 17048} 17049 17050// VCVTSD2SI: Convert Scalar Double-Precision FP Value to Integer. 17051// 17052// Forms: 17053// 17054// VCVTSD2SI xmm r32 17055// VCVTSD2SI m64 r32 17056// Construct and append a VCVTSD2SI instruction to the active function. 17057// Operates on the global context. 17058func VCVTSD2SI(mx, r operand.Op) { ctx.VCVTSD2SI(mx, r) } 17059 17060// VCVTSD2SIQ: Convert Scalar Double-Precision FP Value to Integer. 17061// 17062// Forms: 17063// 17064// VCVTSD2SIQ xmm r64 17065// VCVTSD2SIQ m64 r64 17066// Construct and append a VCVTSD2SIQ instruction to the active function. 17067func (c *Context) VCVTSD2SIQ(mx, r operand.Op) { 17068 if inst, err := x86.VCVTSD2SIQ(mx, r); err == nil { 17069 c.Instruction(inst) 17070 } else { 17071 c.adderror(err) 17072 } 17073} 17074 17075// VCVTSD2SIQ: Convert Scalar Double-Precision FP Value to Integer. 17076// 17077// Forms: 17078// 17079// VCVTSD2SIQ xmm r64 17080// VCVTSD2SIQ m64 r64 17081// Construct and append a VCVTSD2SIQ instruction to the active function. 17082// Operates on the global context. 17083func VCVTSD2SIQ(mx, r operand.Op) { ctx.VCVTSD2SIQ(mx, r) } 17084 17085// VCVTSD2SS: Convert Scalar Double-Precision FP Value to Scalar Single-Precision FP Value. 17086// 17087// Forms: 17088// 17089// VCVTSD2SS xmm xmm xmm 17090// VCVTSD2SS m64 xmm xmm 17091// Construct and append a VCVTSD2SS instruction to the active function. 17092func (c *Context) VCVTSD2SS(mx, x, x1 operand.Op) { 17093 if inst, err := x86.VCVTSD2SS(mx, x, x1); err == nil { 17094 c.Instruction(inst) 17095 } else { 17096 c.adderror(err) 17097 } 17098} 17099 17100// VCVTSD2SS: Convert Scalar Double-Precision FP Value to Scalar Single-Precision FP Value. 17101// 17102// Forms: 17103// 17104// VCVTSD2SS xmm xmm xmm 17105// VCVTSD2SS m64 xmm xmm 17106// Construct and append a VCVTSD2SS instruction to the active function. 17107// Operates on the global context. 17108func VCVTSD2SS(mx, x, x1 operand.Op) { ctx.VCVTSD2SS(mx, x, x1) } 17109 17110// VCVTSI2SDL: Convert Dword Integer to Scalar Double-Precision FP Value. 17111// 17112// Forms: 17113// 17114// VCVTSI2SDL r32 xmm xmm 17115// VCVTSI2SDL m32 xmm xmm 17116// Construct and append a VCVTSI2SDL instruction to the active function. 17117func (c *Context) VCVTSI2SDL(mr, x, x1 operand.Op) { 17118 if inst, err := x86.VCVTSI2SDL(mr, x, x1); err == nil { 17119 c.Instruction(inst) 17120 } else { 17121 c.adderror(err) 17122 } 17123} 17124 17125// VCVTSI2SDL: Convert Dword Integer to Scalar Double-Precision FP Value. 17126// 17127// Forms: 17128// 17129// VCVTSI2SDL r32 xmm xmm 17130// VCVTSI2SDL m32 xmm xmm 17131// Construct and append a VCVTSI2SDL instruction to the active function. 17132// Operates on the global context. 17133func VCVTSI2SDL(mr, x, x1 operand.Op) { ctx.VCVTSI2SDL(mr, x, x1) } 17134 17135// VCVTSI2SDQ: Convert Dword Integer to Scalar Double-Precision FP Value. 17136// 17137// Forms: 17138// 17139// VCVTSI2SDQ r64 xmm xmm 17140// VCVTSI2SDQ m64 xmm xmm 17141// Construct and append a VCVTSI2SDQ instruction to the active function. 17142func (c *Context) VCVTSI2SDQ(mr, x, x1 operand.Op) { 17143 if inst, err := x86.VCVTSI2SDQ(mr, x, x1); err == nil { 17144 c.Instruction(inst) 17145 } else { 17146 c.adderror(err) 17147 } 17148} 17149 17150// VCVTSI2SDQ: Convert Dword Integer to Scalar Double-Precision FP Value. 17151// 17152// Forms: 17153// 17154// VCVTSI2SDQ r64 xmm xmm 17155// VCVTSI2SDQ m64 xmm xmm 17156// Construct and append a VCVTSI2SDQ instruction to the active function. 17157// Operates on the global context. 17158func VCVTSI2SDQ(mr, x, x1 operand.Op) { ctx.VCVTSI2SDQ(mr, x, x1) } 17159 17160// VCVTSI2SSL: Convert Dword Integer to Scalar Single-Precision FP Value. 17161// 17162// Forms: 17163// 17164// VCVTSI2SSL r32 xmm xmm 17165// VCVTSI2SSL m32 xmm xmm 17166// Construct and append a VCVTSI2SSL instruction to the active function. 17167func (c *Context) VCVTSI2SSL(mr, x, x1 operand.Op) { 17168 if inst, err := x86.VCVTSI2SSL(mr, x, x1); err == nil { 17169 c.Instruction(inst) 17170 } else { 17171 c.adderror(err) 17172 } 17173} 17174 17175// VCVTSI2SSL: Convert Dword Integer to Scalar Single-Precision FP Value. 17176// 17177// Forms: 17178// 17179// VCVTSI2SSL r32 xmm xmm 17180// VCVTSI2SSL m32 xmm xmm 17181// Construct and append a VCVTSI2SSL instruction to the active function. 17182// Operates on the global context. 17183func VCVTSI2SSL(mr, x, x1 operand.Op) { ctx.VCVTSI2SSL(mr, x, x1) } 17184 17185// VCVTSI2SSQ: Convert Dword Integer to Scalar Single-Precision FP Value. 17186// 17187// Forms: 17188// 17189// VCVTSI2SSQ r64 xmm xmm 17190// VCVTSI2SSQ m64 xmm xmm 17191// Construct and append a VCVTSI2SSQ instruction to the active function. 17192func (c *Context) VCVTSI2SSQ(mr, x, x1 operand.Op) { 17193 if inst, err := x86.VCVTSI2SSQ(mr, x, x1); err == nil { 17194 c.Instruction(inst) 17195 } else { 17196 c.adderror(err) 17197 } 17198} 17199 17200// VCVTSI2SSQ: Convert Dword Integer to Scalar Single-Precision FP Value. 17201// 17202// Forms: 17203// 17204// VCVTSI2SSQ r64 xmm xmm 17205// VCVTSI2SSQ m64 xmm xmm 17206// Construct and append a VCVTSI2SSQ instruction to the active function. 17207// Operates on the global context. 17208func VCVTSI2SSQ(mr, x, x1 operand.Op) { ctx.VCVTSI2SSQ(mr, x, x1) } 17209 17210// VCVTSS2SD: Convert Scalar Single-Precision FP Value to Scalar Double-Precision FP Value. 17211// 17212// Forms: 17213// 17214// VCVTSS2SD xmm xmm xmm 17215// VCVTSS2SD m32 xmm xmm 17216// Construct and append a VCVTSS2SD instruction to the active function. 17217func (c *Context) VCVTSS2SD(mx, x, x1 operand.Op) { 17218 if inst, err := x86.VCVTSS2SD(mx, x, x1); err == nil { 17219 c.Instruction(inst) 17220 } else { 17221 c.adderror(err) 17222 } 17223} 17224 17225// VCVTSS2SD: Convert Scalar Single-Precision FP Value to Scalar Double-Precision FP Value. 17226// 17227// Forms: 17228// 17229// VCVTSS2SD xmm xmm xmm 17230// VCVTSS2SD m32 xmm xmm 17231// Construct and append a VCVTSS2SD instruction to the active function. 17232// Operates on the global context. 17233func VCVTSS2SD(mx, x, x1 operand.Op) { ctx.VCVTSS2SD(mx, x, x1) } 17234 17235// VCVTSS2SI: Convert Scalar Single-Precision FP Value to Dword Integer. 17236// 17237// Forms: 17238// 17239// VCVTSS2SI xmm r32 17240// VCVTSS2SI m32 r32 17241// Construct and append a VCVTSS2SI instruction to the active function. 17242func (c *Context) VCVTSS2SI(mx, r operand.Op) { 17243 if inst, err := x86.VCVTSS2SI(mx, r); err == nil { 17244 c.Instruction(inst) 17245 } else { 17246 c.adderror(err) 17247 } 17248} 17249 17250// VCVTSS2SI: Convert Scalar Single-Precision FP Value to Dword Integer. 17251// 17252// Forms: 17253// 17254// VCVTSS2SI xmm r32 17255// VCVTSS2SI m32 r32 17256// Construct and append a VCVTSS2SI instruction to the active function. 17257// Operates on the global context. 17258func VCVTSS2SI(mx, r operand.Op) { ctx.VCVTSS2SI(mx, r) } 17259 17260// VCVTSS2SIQ: Convert Scalar Single-Precision FP Value to Dword Integer. 17261// 17262// Forms: 17263// 17264// VCVTSS2SIQ xmm r64 17265// VCVTSS2SIQ m32 r64 17266// Construct and append a VCVTSS2SIQ instruction to the active function. 17267func (c *Context) VCVTSS2SIQ(mx, r operand.Op) { 17268 if inst, err := x86.VCVTSS2SIQ(mx, r); err == nil { 17269 c.Instruction(inst) 17270 } else { 17271 c.adderror(err) 17272 } 17273} 17274 17275// VCVTSS2SIQ: Convert Scalar Single-Precision FP Value to Dword Integer. 17276// 17277// Forms: 17278// 17279// VCVTSS2SIQ xmm r64 17280// VCVTSS2SIQ m32 r64 17281// Construct and append a VCVTSS2SIQ instruction to the active function. 17282// Operates on the global context. 17283func VCVTSS2SIQ(mx, r operand.Op) { ctx.VCVTSS2SIQ(mx, r) } 17284 17285// VCVTTPD2DQX: Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers. 17286// 17287// Forms: 17288// 17289// VCVTTPD2DQX xmm xmm 17290// VCVTTPD2DQX m128 xmm 17291// Construct and append a VCVTTPD2DQX instruction to the active function. 17292func (c *Context) VCVTTPD2DQX(mx, x operand.Op) { 17293 if inst, err := x86.VCVTTPD2DQX(mx, x); err == nil { 17294 c.Instruction(inst) 17295 } else { 17296 c.adderror(err) 17297 } 17298} 17299 17300// VCVTTPD2DQX: Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers. 17301// 17302// Forms: 17303// 17304// VCVTTPD2DQX xmm xmm 17305// VCVTTPD2DQX m128 xmm 17306// Construct and append a VCVTTPD2DQX instruction to the active function. 17307// Operates on the global context. 17308func VCVTTPD2DQX(mx, x operand.Op) { ctx.VCVTTPD2DQX(mx, x) } 17309 17310// VCVTTPD2DQY: Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers. 17311// 17312// Forms: 17313// 17314// VCVTTPD2DQY ymm xmm 17315// VCVTTPD2DQY m256 xmm 17316// Construct and append a VCVTTPD2DQY instruction to the active function. 17317func (c *Context) VCVTTPD2DQY(my, x operand.Op) { 17318 if inst, err := x86.VCVTTPD2DQY(my, x); err == nil { 17319 c.Instruction(inst) 17320 } else { 17321 c.adderror(err) 17322 } 17323} 17324 17325// VCVTTPD2DQY: Convert with Truncation Packed Double-Precision FP Values to Packed Dword Integers. 17326// 17327// Forms: 17328// 17329// VCVTTPD2DQY ymm xmm 17330// VCVTTPD2DQY m256 xmm 17331// Construct and append a VCVTTPD2DQY instruction to the active function. 17332// Operates on the global context. 17333func VCVTTPD2DQY(my, x operand.Op) { ctx.VCVTTPD2DQY(my, x) } 17334 17335// VCVTTPS2DQ: Convert with Truncation Packed Single-Precision FP Values to Packed Dword Integers. 17336// 17337// Forms: 17338// 17339// VCVTTPS2DQ xmm xmm 17340// VCVTTPS2DQ m128 xmm 17341// VCVTTPS2DQ ymm ymm 17342// VCVTTPS2DQ m256 ymm 17343// Construct and append a VCVTTPS2DQ instruction to the active function. 17344func (c *Context) VCVTTPS2DQ(mxy, xy operand.Op) { 17345 if inst, err := x86.VCVTTPS2DQ(mxy, xy); err == nil { 17346 c.Instruction(inst) 17347 } else { 17348 c.adderror(err) 17349 } 17350} 17351 17352// VCVTTPS2DQ: Convert with Truncation Packed Single-Precision FP Values to Packed Dword Integers. 17353// 17354// Forms: 17355// 17356// VCVTTPS2DQ xmm xmm 17357// VCVTTPS2DQ m128 xmm 17358// VCVTTPS2DQ ymm ymm 17359// VCVTTPS2DQ m256 ymm 17360// Construct and append a VCVTTPS2DQ instruction to the active function. 17361// Operates on the global context. 17362func VCVTTPS2DQ(mxy, xy operand.Op) { ctx.VCVTTPS2DQ(mxy, xy) } 17363 17364// VCVTTSD2SI: Convert with Truncation Scalar Double-Precision FP Value to Signed Integer. 17365// 17366// Forms: 17367// 17368// VCVTTSD2SI xmm r32 17369// VCVTTSD2SI m64 r32 17370// Construct and append a VCVTTSD2SI instruction to the active function. 17371func (c *Context) VCVTTSD2SI(mx, r operand.Op) { 17372 if inst, err := x86.VCVTTSD2SI(mx, r); err == nil { 17373 c.Instruction(inst) 17374 } else { 17375 c.adderror(err) 17376 } 17377} 17378 17379// VCVTTSD2SI: Convert with Truncation Scalar Double-Precision FP Value to Signed Integer. 17380// 17381// Forms: 17382// 17383// VCVTTSD2SI xmm r32 17384// VCVTTSD2SI m64 r32 17385// Construct and append a VCVTTSD2SI instruction to the active function. 17386// Operates on the global context. 17387func VCVTTSD2SI(mx, r operand.Op) { ctx.VCVTTSD2SI(mx, r) } 17388 17389// VCVTTSD2SIQ: Convert with Truncation Scalar Double-Precision FP Value to Signed Integer. 17390// 17391// Forms: 17392// 17393// VCVTTSD2SIQ xmm r64 17394// VCVTTSD2SIQ m64 r64 17395// Construct and append a VCVTTSD2SIQ instruction to the active function. 17396func (c *Context) VCVTTSD2SIQ(mx, r operand.Op) { 17397 if inst, err := x86.VCVTTSD2SIQ(mx, r); err == nil { 17398 c.Instruction(inst) 17399 } else { 17400 c.adderror(err) 17401 } 17402} 17403 17404// VCVTTSD2SIQ: Convert with Truncation Scalar Double-Precision FP Value to Signed Integer. 17405// 17406// Forms: 17407// 17408// VCVTTSD2SIQ xmm r64 17409// VCVTTSD2SIQ m64 r64 17410// Construct and append a VCVTTSD2SIQ instruction to the active function. 17411// Operates on the global context. 17412func VCVTTSD2SIQ(mx, r operand.Op) { ctx.VCVTTSD2SIQ(mx, r) } 17413 17414// VCVTTSS2SI: Convert with Truncation Scalar Single-Precision FP Value to Dword Integer. 17415// 17416// Forms: 17417// 17418// VCVTTSS2SI xmm r32 17419// VCVTTSS2SI m32 r32 17420// Construct and append a VCVTTSS2SI instruction to the active function. 17421func (c *Context) VCVTTSS2SI(mx, r operand.Op) { 17422 if inst, err := x86.VCVTTSS2SI(mx, r); err == nil { 17423 c.Instruction(inst) 17424 } else { 17425 c.adderror(err) 17426 } 17427} 17428 17429// VCVTTSS2SI: Convert with Truncation Scalar Single-Precision FP Value to Dword Integer. 17430// 17431// Forms: 17432// 17433// VCVTTSS2SI xmm r32 17434// VCVTTSS2SI m32 r32 17435// Construct and append a VCVTTSS2SI instruction to the active function. 17436// Operates on the global context. 17437func VCVTTSS2SI(mx, r operand.Op) { ctx.VCVTTSS2SI(mx, r) } 17438 17439// VCVTTSS2SIQ: Convert with Truncation Scalar Single-Precision FP Value to Dword Integer. 17440// 17441// Forms: 17442// 17443// VCVTTSS2SIQ xmm r64 17444// VCVTTSS2SIQ m32 r64 17445// Construct and append a VCVTTSS2SIQ instruction to the active function. 17446func (c *Context) VCVTTSS2SIQ(mx, r operand.Op) { 17447 if inst, err := x86.VCVTTSS2SIQ(mx, r); err == nil { 17448 c.Instruction(inst) 17449 } else { 17450 c.adderror(err) 17451 } 17452} 17453 17454// VCVTTSS2SIQ: Convert with Truncation Scalar Single-Precision FP Value to Dword Integer. 17455// 17456// Forms: 17457// 17458// VCVTTSS2SIQ xmm r64 17459// VCVTTSS2SIQ m32 r64 17460// Construct and append a VCVTTSS2SIQ instruction to the active function. 17461// Operates on the global context. 17462func VCVTTSS2SIQ(mx, r operand.Op) { ctx.VCVTTSS2SIQ(mx, r) } 17463 17464// VDIVPD: Divide Packed Double-Precision Floating-Point Values. 17465// 17466// Forms: 17467// 17468// VDIVPD xmm xmm xmm 17469// VDIVPD m128 xmm xmm 17470// VDIVPD ymm ymm ymm 17471// VDIVPD m256 ymm ymm 17472// Construct and append a VDIVPD instruction to the active function. 17473func (c *Context) VDIVPD(mxy, xy, xy1 operand.Op) { 17474 if inst, err := x86.VDIVPD(mxy, xy, xy1); err == nil { 17475 c.Instruction(inst) 17476 } else { 17477 c.adderror(err) 17478 } 17479} 17480 17481// VDIVPD: Divide Packed Double-Precision Floating-Point Values. 17482// 17483// Forms: 17484// 17485// VDIVPD xmm xmm xmm 17486// VDIVPD m128 xmm xmm 17487// VDIVPD ymm ymm ymm 17488// VDIVPD m256 ymm ymm 17489// Construct and append a VDIVPD instruction to the active function. 17490// Operates on the global context. 17491func VDIVPD(mxy, xy, xy1 operand.Op) { ctx.VDIVPD(mxy, xy, xy1) } 17492 17493// VDIVPS: Divide Packed Single-Precision Floating-Point Values. 17494// 17495// Forms: 17496// 17497// VDIVPS xmm xmm xmm 17498// VDIVPS m128 xmm xmm 17499// VDIVPS ymm ymm ymm 17500// VDIVPS m256 ymm ymm 17501// Construct and append a VDIVPS instruction to the active function. 17502func (c *Context) VDIVPS(mxy, xy, xy1 operand.Op) { 17503 if inst, err := x86.VDIVPS(mxy, xy, xy1); err == nil { 17504 c.Instruction(inst) 17505 } else { 17506 c.adderror(err) 17507 } 17508} 17509 17510// VDIVPS: Divide Packed Single-Precision Floating-Point Values. 17511// 17512// Forms: 17513// 17514// VDIVPS xmm xmm xmm 17515// VDIVPS m128 xmm xmm 17516// VDIVPS ymm ymm ymm 17517// VDIVPS m256 ymm ymm 17518// Construct and append a VDIVPS instruction to the active function. 17519// Operates on the global context. 17520func VDIVPS(mxy, xy, xy1 operand.Op) { ctx.VDIVPS(mxy, xy, xy1) } 17521 17522// VDIVSD: Divide Scalar Double-Precision Floating-Point Values. 17523// 17524// Forms: 17525// 17526// VDIVSD xmm xmm xmm 17527// VDIVSD m64 xmm xmm 17528// Construct and append a VDIVSD instruction to the active function. 17529func (c *Context) VDIVSD(mx, x, x1 operand.Op) { 17530 if inst, err := x86.VDIVSD(mx, x, x1); err == nil { 17531 c.Instruction(inst) 17532 } else { 17533 c.adderror(err) 17534 } 17535} 17536 17537// VDIVSD: Divide Scalar Double-Precision Floating-Point Values. 17538// 17539// Forms: 17540// 17541// VDIVSD xmm xmm xmm 17542// VDIVSD m64 xmm xmm 17543// Construct and append a VDIVSD instruction to the active function. 17544// Operates on the global context. 17545func VDIVSD(mx, x, x1 operand.Op) { ctx.VDIVSD(mx, x, x1) } 17546 17547// VDIVSS: Divide Scalar Single-Precision Floating-Point Values. 17548// 17549// Forms: 17550// 17551// VDIVSS xmm xmm xmm 17552// VDIVSS m32 xmm xmm 17553// Construct and append a VDIVSS instruction to the active function. 17554func (c *Context) VDIVSS(mx, x, x1 operand.Op) { 17555 if inst, err := x86.VDIVSS(mx, x, x1); err == nil { 17556 c.Instruction(inst) 17557 } else { 17558 c.adderror(err) 17559 } 17560} 17561 17562// VDIVSS: Divide Scalar Single-Precision Floating-Point Values. 17563// 17564// Forms: 17565// 17566// VDIVSS xmm xmm xmm 17567// VDIVSS m32 xmm xmm 17568// Construct and append a VDIVSS instruction to the active function. 17569// Operates on the global context. 17570func VDIVSS(mx, x, x1 operand.Op) { ctx.VDIVSS(mx, x, x1) } 17571 17572// VDPPD: Dot Product of Packed Double Precision Floating-Point Values. 17573// 17574// Forms: 17575// 17576// VDPPD imm8 xmm xmm xmm 17577// VDPPD imm8 m128 xmm xmm 17578// Construct and append a VDPPD instruction to the active function. 17579func (c *Context) VDPPD(i, mx, x, x1 operand.Op) { 17580 if inst, err := x86.VDPPD(i, mx, x, x1); err == nil { 17581 c.Instruction(inst) 17582 } else { 17583 c.adderror(err) 17584 } 17585} 17586 17587// VDPPD: Dot Product of Packed Double Precision Floating-Point Values. 17588// 17589// Forms: 17590// 17591// VDPPD imm8 xmm xmm xmm 17592// VDPPD imm8 m128 xmm xmm 17593// Construct and append a VDPPD instruction to the active function. 17594// Operates on the global context. 17595func VDPPD(i, mx, x, x1 operand.Op) { ctx.VDPPD(i, mx, x, x1) } 17596 17597// VDPPS: Dot Product of Packed Single Precision Floating-Point Values. 17598// 17599// Forms: 17600// 17601// VDPPS imm8 xmm xmm xmm 17602// VDPPS imm8 m128 xmm xmm 17603// VDPPS imm8 ymm ymm ymm 17604// VDPPS imm8 m256 ymm ymm 17605// Construct and append a VDPPS instruction to the active function. 17606func (c *Context) VDPPS(i, mxy, xy, xy1 operand.Op) { 17607 if inst, err := x86.VDPPS(i, mxy, xy, xy1); err == nil { 17608 c.Instruction(inst) 17609 } else { 17610 c.adderror(err) 17611 } 17612} 17613 17614// VDPPS: Dot Product of Packed Single Precision Floating-Point Values. 17615// 17616// Forms: 17617// 17618// VDPPS imm8 xmm xmm xmm 17619// VDPPS imm8 m128 xmm xmm 17620// VDPPS imm8 ymm ymm ymm 17621// VDPPS imm8 m256 ymm ymm 17622// Construct and append a VDPPS instruction to the active function. 17623// Operates on the global context. 17624func VDPPS(i, mxy, xy, xy1 operand.Op) { ctx.VDPPS(i, mxy, xy, xy1) } 17625 17626// VEXTRACTF128: Extract Packed Floating-Point Values. 17627// 17628// Forms: 17629// 17630// VEXTRACTF128 imm8 ymm xmm 17631// VEXTRACTF128 imm8 ymm m128 17632// Construct and append a VEXTRACTF128 instruction to the active function. 17633func (c *Context) VEXTRACTF128(i, y, mx operand.Op) { 17634 if inst, err := x86.VEXTRACTF128(i, y, mx); err == nil { 17635 c.Instruction(inst) 17636 } else { 17637 c.adderror(err) 17638 } 17639} 17640 17641// VEXTRACTF128: Extract Packed Floating-Point Values. 17642// 17643// Forms: 17644// 17645// VEXTRACTF128 imm8 ymm xmm 17646// VEXTRACTF128 imm8 ymm m128 17647// Construct and append a VEXTRACTF128 instruction to the active function. 17648// Operates on the global context. 17649func VEXTRACTF128(i, y, mx operand.Op) { ctx.VEXTRACTF128(i, y, mx) } 17650 17651// VEXTRACTI128: Extract Packed Integer Values. 17652// 17653// Forms: 17654// 17655// VEXTRACTI128 imm8 ymm xmm 17656// VEXTRACTI128 imm8 ymm m128 17657// Construct and append a VEXTRACTI128 instruction to the active function. 17658func (c *Context) VEXTRACTI128(i, y, mx operand.Op) { 17659 if inst, err := x86.VEXTRACTI128(i, y, mx); err == nil { 17660 c.Instruction(inst) 17661 } else { 17662 c.adderror(err) 17663 } 17664} 17665 17666// VEXTRACTI128: Extract Packed Integer Values. 17667// 17668// Forms: 17669// 17670// VEXTRACTI128 imm8 ymm xmm 17671// VEXTRACTI128 imm8 ymm m128 17672// Construct and append a VEXTRACTI128 instruction to the active function. 17673// Operates on the global context. 17674func VEXTRACTI128(i, y, mx operand.Op) { ctx.VEXTRACTI128(i, y, mx) } 17675 17676// VEXTRACTPS: Extract Packed Single Precision Floating-Point Value. 17677// 17678// Forms: 17679// 17680// VEXTRACTPS imm8 xmm r32 17681// VEXTRACTPS imm8 xmm m32 17682// Construct and append a VEXTRACTPS instruction to the active function. 17683func (c *Context) VEXTRACTPS(i, x, mr operand.Op) { 17684 if inst, err := x86.VEXTRACTPS(i, x, mr); err == nil { 17685 c.Instruction(inst) 17686 } else { 17687 c.adderror(err) 17688 } 17689} 17690 17691// VEXTRACTPS: Extract Packed Single Precision Floating-Point Value. 17692// 17693// Forms: 17694// 17695// VEXTRACTPS imm8 xmm r32 17696// VEXTRACTPS imm8 xmm m32 17697// Construct and append a VEXTRACTPS instruction to the active function. 17698// Operates on the global context. 17699func VEXTRACTPS(i, x, mr operand.Op) { ctx.VEXTRACTPS(i, x, mr) } 17700 17701// VFMADD132PD: Fused Multiply-Add of Packed Double-Precision Floating-Point Values. 17702// 17703// Forms: 17704// 17705// VFMADD132PD xmm xmm xmm 17706// VFMADD132PD m128 xmm xmm 17707// VFMADD132PD ymm ymm ymm 17708// VFMADD132PD m256 ymm ymm 17709// Construct and append a VFMADD132PD instruction to the active function. 17710func (c *Context) VFMADD132PD(mxy, xy, xy1 operand.Op) { 17711 if inst, err := x86.VFMADD132PD(mxy, xy, xy1); err == nil { 17712 c.Instruction(inst) 17713 } else { 17714 c.adderror(err) 17715 } 17716} 17717 17718// VFMADD132PD: Fused Multiply-Add of Packed Double-Precision Floating-Point Values. 17719// 17720// Forms: 17721// 17722// VFMADD132PD xmm xmm xmm 17723// VFMADD132PD m128 xmm xmm 17724// VFMADD132PD ymm ymm ymm 17725// VFMADD132PD m256 ymm ymm 17726// Construct and append a VFMADD132PD instruction to the active function. 17727// Operates on the global context. 17728func VFMADD132PD(mxy, xy, xy1 operand.Op) { ctx.VFMADD132PD(mxy, xy, xy1) } 17729 17730// VFMADD132PS: Fused Multiply-Add of Packed Single-Precision Floating-Point Values. 17731// 17732// Forms: 17733// 17734// VFMADD132PS xmm xmm xmm 17735// VFMADD132PS m128 xmm xmm 17736// VFMADD132PS ymm ymm ymm 17737// VFMADD132PS m256 ymm ymm 17738// Construct and append a VFMADD132PS instruction to the active function. 17739func (c *Context) VFMADD132PS(mxy, xy, xy1 operand.Op) { 17740 if inst, err := x86.VFMADD132PS(mxy, xy, xy1); err == nil { 17741 c.Instruction(inst) 17742 } else { 17743 c.adderror(err) 17744 } 17745} 17746 17747// VFMADD132PS: Fused Multiply-Add of Packed Single-Precision Floating-Point Values. 17748// 17749// Forms: 17750// 17751// VFMADD132PS xmm xmm xmm 17752// VFMADD132PS m128 xmm xmm 17753// VFMADD132PS ymm ymm ymm 17754// VFMADD132PS m256 ymm ymm 17755// Construct and append a VFMADD132PS instruction to the active function. 17756// Operates on the global context. 17757func VFMADD132PS(mxy, xy, xy1 operand.Op) { ctx.VFMADD132PS(mxy, xy, xy1) } 17758 17759// VFMADD132SD: Fused Multiply-Add of Scalar Double-Precision Floating-Point Values. 17760// 17761// Forms: 17762// 17763// VFMADD132SD xmm xmm xmm 17764// VFMADD132SD m64 xmm xmm 17765// Construct and append a VFMADD132SD instruction to the active function. 17766func (c *Context) VFMADD132SD(mx, x, x1 operand.Op) { 17767 if inst, err := x86.VFMADD132SD(mx, x, x1); err == nil { 17768 c.Instruction(inst) 17769 } else { 17770 c.adderror(err) 17771 } 17772} 17773 17774// VFMADD132SD: Fused Multiply-Add of Scalar Double-Precision Floating-Point Values. 17775// 17776// Forms: 17777// 17778// VFMADD132SD xmm xmm xmm 17779// VFMADD132SD m64 xmm xmm 17780// Construct and append a VFMADD132SD instruction to the active function. 17781// Operates on the global context. 17782func VFMADD132SD(mx, x, x1 operand.Op) { ctx.VFMADD132SD(mx, x, x1) } 17783 17784// VFMADD132SS: Fused Multiply-Add of Scalar Single-Precision Floating-Point Values. 17785// 17786// Forms: 17787// 17788// VFMADD132SS xmm xmm xmm 17789// VFMADD132SS m32 xmm xmm 17790// Construct and append a VFMADD132SS instruction to the active function. 17791func (c *Context) VFMADD132SS(mx, x, x1 operand.Op) { 17792 if inst, err := x86.VFMADD132SS(mx, x, x1); err == nil { 17793 c.Instruction(inst) 17794 } else { 17795 c.adderror(err) 17796 } 17797} 17798 17799// VFMADD132SS: Fused Multiply-Add of Scalar Single-Precision Floating-Point Values. 17800// 17801// Forms: 17802// 17803// VFMADD132SS xmm xmm xmm 17804// VFMADD132SS m32 xmm xmm 17805// Construct and append a VFMADD132SS instruction to the active function. 17806// Operates on the global context. 17807func VFMADD132SS(mx, x, x1 operand.Op) { ctx.VFMADD132SS(mx, x, x1) } 17808 17809// VFMADD213PD: Fused Multiply-Add of Packed Double-Precision Floating-Point Values. 17810// 17811// Forms: 17812// 17813// VFMADD213PD xmm xmm xmm 17814// VFMADD213PD m128 xmm xmm 17815// VFMADD213PD ymm ymm ymm 17816// VFMADD213PD m256 ymm ymm 17817// Construct and append a VFMADD213PD instruction to the active function. 17818func (c *Context) VFMADD213PD(mxy, xy, xy1 operand.Op) { 17819 if inst, err := x86.VFMADD213PD(mxy, xy, xy1); err == nil { 17820 c.Instruction(inst) 17821 } else { 17822 c.adderror(err) 17823 } 17824} 17825 17826// VFMADD213PD: Fused Multiply-Add of Packed Double-Precision Floating-Point Values. 17827// 17828// Forms: 17829// 17830// VFMADD213PD xmm xmm xmm 17831// VFMADD213PD m128 xmm xmm 17832// VFMADD213PD ymm ymm ymm 17833// VFMADD213PD m256 ymm ymm 17834// Construct and append a VFMADD213PD instruction to the active function. 17835// Operates on the global context. 17836func VFMADD213PD(mxy, xy, xy1 operand.Op) { ctx.VFMADD213PD(mxy, xy, xy1) } 17837 17838// VFMADD213PS: Fused Multiply-Add of Packed Single-Precision Floating-Point Values. 17839// 17840// Forms: 17841// 17842// VFMADD213PS xmm xmm xmm 17843// VFMADD213PS m128 xmm xmm 17844// VFMADD213PS ymm ymm ymm 17845// VFMADD213PS m256 ymm ymm 17846// Construct and append a VFMADD213PS instruction to the active function. 17847func (c *Context) VFMADD213PS(mxy, xy, xy1 operand.Op) { 17848 if inst, err := x86.VFMADD213PS(mxy, xy, xy1); err == nil { 17849 c.Instruction(inst) 17850 } else { 17851 c.adderror(err) 17852 } 17853} 17854 17855// VFMADD213PS: Fused Multiply-Add of Packed Single-Precision Floating-Point Values. 17856// 17857// Forms: 17858// 17859// VFMADD213PS xmm xmm xmm 17860// VFMADD213PS m128 xmm xmm 17861// VFMADD213PS ymm ymm ymm 17862// VFMADD213PS m256 ymm ymm 17863// Construct and append a VFMADD213PS instruction to the active function. 17864// Operates on the global context. 17865func VFMADD213PS(mxy, xy, xy1 operand.Op) { ctx.VFMADD213PS(mxy, xy, xy1) } 17866 17867// VFMADD213SD: Fused Multiply-Add of Scalar Double-Precision Floating-Point Values. 17868// 17869// Forms: 17870// 17871// VFMADD213SD xmm xmm xmm 17872// VFMADD213SD m64 xmm xmm 17873// Construct and append a VFMADD213SD instruction to the active function. 17874func (c *Context) VFMADD213SD(mx, x, x1 operand.Op) { 17875 if inst, err := x86.VFMADD213SD(mx, x, x1); err == nil { 17876 c.Instruction(inst) 17877 } else { 17878 c.adderror(err) 17879 } 17880} 17881 17882// VFMADD213SD: Fused Multiply-Add of Scalar Double-Precision Floating-Point Values. 17883// 17884// Forms: 17885// 17886// VFMADD213SD xmm xmm xmm 17887// VFMADD213SD m64 xmm xmm 17888// Construct and append a VFMADD213SD instruction to the active function. 17889// Operates on the global context. 17890func VFMADD213SD(mx, x, x1 operand.Op) { ctx.VFMADD213SD(mx, x, x1) } 17891 17892// VFMADD213SS: Fused Multiply-Add of Scalar Single-Precision Floating-Point Values. 17893// 17894// Forms: 17895// 17896// VFMADD213SS xmm xmm xmm 17897// VFMADD213SS m32 xmm xmm 17898// Construct and append a VFMADD213SS instruction to the active function. 17899func (c *Context) VFMADD213SS(mx, x, x1 operand.Op) { 17900 if inst, err := x86.VFMADD213SS(mx, x, x1); err == nil { 17901 c.Instruction(inst) 17902 } else { 17903 c.adderror(err) 17904 } 17905} 17906 17907// VFMADD213SS: Fused Multiply-Add of Scalar Single-Precision Floating-Point Values. 17908// 17909// Forms: 17910// 17911// VFMADD213SS xmm xmm xmm 17912// VFMADD213SS m32 xmm xmm 17913// Construct and append a VFMADD213SS instruction to the active function. 17914// Operates on the global context. 17915func VFMADD213SS(mx, x, x1 operand.Op) { ctx.VFMADD213SS(mx, x, x1) } 17916 17917// VFMADD231PD: Fused Multiply-Add of Packed Double-Precision Floating-Point Values. 17918// 17919// Forms: 17920// 17921// VFMADD231PD xmm xmm xmm 17922// VFMADD231PD m128 xmm xmm 17923// VFMADD231PD ymm ymm ymm 17924// VFMADD231PD m256 ymm ymm 17925// Construct and append a VFMADD231PD instruction to the active function. 17926func (c *Context) VFMADD231PD(mxy, xy, xy1 operand.Op) { 17927 if inst, err := x86.VFMADD231PD(mxy, xy, xy1); err == nil { 17928 c.Instruction(inst) 17929 } else { 17930 c.adderror(err) 17931 } 17932} 17933 17934// VFMADD231PD: Fused Multiply-Add of Packed Double-Precision Floating-Point Values. 17935// 17936// Forms: 17937// 17938// VFMADD231PD xmm xmm xmm 17939// VFMADD231PD m128 xmm xmm 17940// VFMADD231PD ymm ymm ymm 17941// VFMADD231PD m256 ymm ymm 17942// Construct and append a VFMADD231PD instruction to the active function. 17943// Operates on the global context. 17944func VFMADD231PD(mxy, xy, xy1 operand.Op) { ctx.VFMADD231PD(mxy, xy, xy1) } 17945 17946// VFMADD231PS: Fused Multiply-Add of Packed Single-Precision Floating-Point Values. 17947// 17948// Forms: 17949// 17950// VFMADD231PS xmm xmm xmm 17951// VFMADD231PS m128 xmm xmm 17952// VFMADD231PS ymm ymm ymm 17953// VFMADD231PS m256 ymm ymm 17954// Construct and append a VFMADD231PS instruction to the active function. 17955func (c *Context) VFMADD231PS(mxy, xy, xy1 operand.Op) { 17956 if inst, err := x86.VFMADD231PS(mxy, xy, xy1); err == nil { 17957 c.Instruction(inst) 17958 } else { 17959 c.adderror(err) 17960 } 17961} 17962 17963// VFMADD231PS: Fused Multiply-Add of Packed Single-Precision Floating-Point Values. 17964// 17965// Forms: 17966// 17967// VFMADD231PS xmm xmm xmm 17968// VFMADD231PS m128 xmm xmm 17969// VFMADD231PS ymm ymm ymm 17970// VFMADD231PS m256 ymm ymm 17971// Construct and append a VFMADD231PS instruction to the active function. 17972// Operates on the global context. 17973func VFMADD231PS(mxy, xy, xy1 operand.Op) { ctx.VFMADD231PS(mxy, xy, xy1) } 17974 17975// VFMADD231SD: Fused Multiply-Add of Scalar Double-Precision Floating-Point Values. 17976// 17977// Forms: 17978// 17979// VFMADD231SD xmm xmm xmm 17980// VFMADD231SD m64 xmm xmm 17981// Construct and append a VFMADD231SD instruction to the active function. 17982func (c *Context) VFMADD231SD(mx, x, x1 operand.Op) { 17983 if inst, err := x86.VFMADD231SD(mx, x, x1); err == nil { 17984 c.Instruction(inst) 17985 } else { 17986 c.adderror(err) 17987 } 17988} 17989 17990// VFMADD231SD: Fused Multiply-Add of Scalar Double-Precision Floating-Point Values. 17991// 17992// Forms: 17993// 17994// VFMADD231SD xmm xmm xmm 17995// VFMADD231SD m64 xmm xmm 17996// Construct and append a VFMADD231SD instruction to the active function. 17997// Operates on the global context. 17998func VFMADD231SD(mx, x, x1 operand.Op) { ctx.VFMADD231SD(mx, x, x1) } 17999 18000// VFMADD231SS: Fused Multiply-Add of Scalar Single-Precision Floating-Point Values. 18001// 18002// Forms: 18003// 18004// VFMADD231SS xmm xmm xmm 18005// VFMADD231SS m32 xmm xmm 18006// Construct and append a VFMADD231SS instruction to the active function. 18007func (c *Context) VFMADD231SS(mx, x, x1 operand.Op) { 18008 if inst, err := x86.VFMADD231SS(mx, x, x1); err == nil { 18009 c.Instruction(inst) 18010 } else { 18011 c.adderror(err) 18012 } 18013} 18014 18015// VFMADD231SS: Fused Multiply-Add of Scalar Single-Precision Floating-Point Values. 18016// 18017// Forms: 18018// 18019// VFMADD231SS xmm xmm xmm 18020// VFMADD231SS m32 xmm xmm 18021// Construct and append a VFMADD231SS instruction to the active function. 18022// Operates on the global context. 18023func VFMADD231SS(mx, x, x1 operand.Op) { ctx.VFMADD231SS(mx, x, x1) } 18024 18025// VFMADDSUB132PD: Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values. 18026// 18027// Forms: 18028// 18029// VFMADDSUB132PD xmm xmm xmm 18030// VFMADDSUB132PD m128 xmm xmm 18031// VFMADDSUB132PD ymm ymm ymm 18032// VFMADDSUB132PD m256 ymm ymm 18033// Construct and append a VFMADDSUB132PD instruction to the active function. 18034func (c *Context) VFMADDSUB132PD(mxy, xy, xy1 operand.Op) { 18035 if inst, err := x86.VFMADDSUB132PD(mxy, xy, xy1); err == nil { 18036 c.Instruction(inst) 18037 } else { 18038 c.adderror(err) 18039 } 18040} 18041 18042// VFMADDSUB132PD: Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values. 18043// 18044// Forms: 18045// 18046// VFMADDSUB132PD xmm xmm xmm 18047// VFMADDSUB132PD m128 xmm xmm 18048// VFMADDSUB132PD ymm ymm ymm 18049// VFMADDSUB132PD m256 ymm ymm 18050// Construct and append a VFMADDSUB132PD instruction to the active function. 18051// Operates on the global context. 18052func VFMADDSUB132PD(mxy, xy, xy1 operand.Op) { ctx.VFMADDSUB132PD(mxy, xy, xy1) } 18053 18054// VFMADDSUB132PS: Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values. 18055// 18056// Forms: 18057// 18058// VFMADDSUB132PS xmm xmm xmm 18059// VFMADDSUB132PS m128 xmm xmm 18060// VFMADDSUB132PS ymm ymm ymm 18061// VFMADDSUB132PS m256 ymm ymm 18062// Construct and append a VFMADDSUB132PS instruction to the active function. 18063func (c *Context) VFMADDSUB132PS(mxy, xy, xy1 operand.Op) { 18064 if inst, err := x86.VFMADDSUB132PS(mxy, xy, xy1); err == nil { 18065 c.Instruction(inst) 18066 } else { 18067 c.adderror(err) 18068 } 18069} 18070 18071// VFMADDSUB132PS: Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values. 18072// 18073// Forms: 18074// 18075// VFMADDSUB132PS xmm xmm xmm 18076// VFMADDSUB132PS m128 xmm xmm 18077// VFMADDSUB132PS ymm ymm ymm 18078// VFMADDSUB132PS m256 ymm ymm 18079// Construct and append a VFMADDSUB132PS instruction to the active function. 18080// Operates on the global context. 18081func VFMADDSUB132PS(mxy, xy, xy1 operand.Op) { ctx.VFMADDSUB132PS(mxy, xy, xy1) } 18082 18083// VFMADDSUB213PD: Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values. 18084// 18085// Forms: 18086// 18087// VFMADDSUB213PD xmm xmm xmm 18088// VFMADDSUB213PD m128 xmm xmm 18089// VFMADDSUB213PD ymm ymm ymm 18090// VFMADDSUB213PD m256 ymm ymm 18091// Construct and append a VFMADDSUB213PD instruction to the active function. 18092func (c *Context) VFMADDSUB213PD(mxy, xy, xy1 operand.Op) { 18093 if inst, err := x86.VFMADDSUB213PD(mxy, xy, xy1); err == nil { 18094 c.Instruction(inst) 18095 } else { 18096 c.adderror(err) 18097 } 18098} 18099 18100// VFMADDSUB213PD: Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values. 18101// 18102// Forms: 18103// 18104// VFMADDSUB213PD xmm xmm xmm 18105// VFMADDSUB213PD m128 xmm xmm 18106// VFMADDSUB213PD ymm ymm ymm 18107// VFMADDSUB213PD m256 ymm ymm 18108// Construct and append a VFMADDSUB213PD instruction to the active function. 18109// Operates on the global context. 18110func VFMADDSUB213PD(mxy, xy, xy1 operand.Op) { ctx.VFMADDSUB213PD(mxy, xy, xy1) } 18111 18112// VFMADDSUB213PS: Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values. 18113// 18114// Forms: 18115// 18116// VFMADDSUB213PS xmm xmm xmm 18117// VFMADDSUB213PS m128 xmm xmm 18118// VFMADDSUB213PS ymm ymm ymm 18119// VFMADDSUB213PS m256 ymm ymm 18120// Construct and append a VFMADDSUB213PS instruction to the active function. 18121func (c *Context) VFMADDSUB213PS(mxy, xy, xy1 operand.Op) { 18122 if inst, err := x86.VFMADDSUB213PS(mxy, xy, xy1); err == nil { 18123 c.Instruction(inst) 18124 } else { 18125 c.adderror(err) 18126 } 18127} 18128 18129// VFMADDSUB213PS: Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values. 18130// 18131// Forms: 18132// 18133// VFMADDSUB213PS xmm xmm xmm 18134// VFMADDSUB213PS m128 xmm xmm 18135// VFMADDSUB213PS ymm ymm ymm 18136// VFMADDSUB213PS m256 ymm ymm 18137// Construct and append a VFMADDSUB213PS instruction to the active function. 18138// Operates on the global context. 18139func VFMADDSUB213PS(mxy, xy, xy1 operand.Op) { ctx.VFMADDSUB213PS(mxy, xy, xy1) } 18140 18141// VFMADDSUB231PD: Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values. 18142// 18143// Forms: 18144// 18145// VFMADDSUB231PD xmm xmm xmm 18146// VFMADDSUB231PD m128 xmm xmm 18147// VFMADDSUB231PD ymm ymm ymm 18148// VFMADDSUB231PD m256 ymm ymm 18149// Construct and append a VFMADDSUB231PD instruction to the active function. 18150func (c *Context) VFMADDSUB231PD(mxy, xy, xy1 operand.Op) { 18151 if inst, err := x86.VFMADDSUB231PD(mxy, xy, xy1); err == nil { 18152 c.Instruction(inst) 18153 } else { 18154 c.adderror(err) 18155 } 18156} 18157 18158// VFMADDSUB231PD: Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values. 18159// 18160// Forms: 18161// 18162// VFMADDSUB231PD xmm xmm xmm 18163// VFMADDSUB231PD m128 xmm xmm 18164// VFMADDSUB231PD ymm ymm ymm 18165// VFMADDSUB231PD m256 ymm ymm 18166// Construct and append a VFMADDSUB231PD instruction to the active function. 18167// Operates on the global context. 18168func VFMADDSUB231PD(mxy, xy, xy1 operand.Op) { ctx.VFMADDSUB231PD(mxy, xy, xy1) } 18169 18170// VFMADDSUB231PS: Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values. 18171// 18172// Forms: 18173// 18174// VFMADDSUB231PS xmm xmm xmm 18175// VFMADDSUB231PS m128 xmm xmm 18176// VFMADDSUB231PS ymm ymm ymm 18177// VFMADDSUB231PS m256 ymm ymm 18178// Construct and append a VFMADDSUB231PS instruction to the active function. 18179func (c *Context) VFMADDSUB231PS(mxy, xy, xy1 operand.Op) { 18180 if inst, err := x86.VFMADDSUB231PS(mxy, xy, xy1); err == nil { 18181 c.Instruction(inst) 18182 } else { 18183 c.adderror(err) 18184 } 18185} 18186 18187// VFMADDSUB231PS: Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values. 18188// 18189// Forms: 18190// 18191// VFMADDSUB231PS xmm xmm xmm 18192// VFMADDSUB231PS m128 xmm xmm 18193// VFMADDSUB231PS ymm ymm ymm 18194// VFMADDSUB231PS m256 ymm ymm 18195// Construct and append a VFMADDSUB231PS instruction to the active function. 18196// Operates on the global context. 18197func VFMADDSUB231PS(mxy, xy, xy1 operand.Op) { ctx.VFMADDSUB231PS(mxy, xy, xy1) } 18198 18199// VFMSUB132PD: Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values. 18200// 18201// Forms: 18202// 18203// VFMSUB132PD xmm xmm xmm 18204// VFMSUB132PD m128 xmm xmm 18205// VFMSUB132PD ymm ymm ymm 18206// VFMSUB132PD m256 ymm ymm 18207// Construct and append a VFMSUB132PD instruction to the active function. 18208func (c *Context) VFMSUB132PD(mxy, xy, xy1 operand.Op) { 18209 if inst, err := x86.VFMSUB132PD(mxy, xy, xy1); err == nil { 18210 c.Instruction(inst) 18211 } else { 18212 c.adderror(err) 18213 } 18214} 18215 18216// VFMSUB132PD: Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values. 18217// 18218// Forms: 18219// 18220// VFMSUB132PD xmm xmm xmm 18221// VFMSUB132PD m128 xmm xmm 18222// VFMSUB132PD ymm ymm ymm 18223// VFMSUB132PD m256 ymm ymm 18224// Construct and append a VFMSUB132PD instruction to the active function. 18225// Operates on the global context. 18226func VFMSUB132PD(mxy, xy, xy1 operand.Op) { ctx.VFMSUB132PD(mxy, xy, xy1) } 18227 18228// VFMSUB132PS: Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values. 18229// 18230// Forms: 18231// 18232// VFMSUB132PS xmm xmm xmm 18233// VFMSUB132PS m128 xmm xmm 18234// VFMSUB132PS ymm ymm ymm 18235// VFMSUB132PS m256 ymm ymm 18236// Construct and append a VFMSUB132PS instruction to the active function. 18237func (c *Context) VFMSUB132PS(mxy, xy, xy1 operand.Op) { 18238 if inst, err := x86.VFMSUB132PS(mxy, xy, xy1); err == nil { 18239 c.Instruction(inst) 18240 } else { 18241 c.adderror(err) 18242 } 18243} 18244 18245// VFMSUB132PS: Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values. 18246// 18247// Forms: 18248// 18249// VFMSUB132PS xmm xmm xmm 18250// VFMSUB132PS m128 xmm xmm 18251// VFMSUB132PS ymm ymm ymm 18252// VFMSUB132PS m256 ymm ymm 18253// Construct and append a VFMSUB132PS instruction to the active function. 18254// Operates on the global context. 18255func VFMSUB132PS(mxy, xy, xy1 operand.Op) { ctx.VFMSUB132PS(mxy, xy, xy1) } 18256 18257// VFMSUB132SD: Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values. 18258// 18259// Forms: 18260// 18261// VFMSUB132SD xmm xmm xmm 18262// VFMSUB132SD m64 xmm xmm 18263// Construct and append a VFMSUB132SD instruction to the active function. 18264func (c *Context) VFMSUB132SD(mx, x, x1 operand.Op) { 18265 if inst, err := x86.VFMSUB132SD(mx, x, x1); err == nil { 18266 c.Instruction(inst) 18267 } else { 18268 c.adderror(err) 18269 } 18270} 18271 18272// VFMSUB132SD: Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values. 18273// 18274// Forms: 18275// 18276// VFMSUB132SD xmm xmm xmm 18277// VFMSUB132SD m64 xmm xmm 18278// Construct and append a VFMSUB132SD instruction to the active function. 18279// Operates on the global context. 18280func VFMSUB132SD(mx, x, x1 operand.Op) { ctx.VFMSUB132SD(mx, x, x1) } 18281 18282// VFMSUB132SS: Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values. 18283// 18284// Forms: 18285// 18286// VFMSUB132SS xmm xmm xmm 18287// VFMSUB132SS m32 xmm xmm 18288// Construct and append a VFMSUB132SS instruction to the active function. 18289func (c *Context) VFMSUB132SS(mx, x, x1 operand.Op) { 18290 if inst, err := x86.VFMSUB132SS(mx, x, x1); err == nil { 18291 c.Instruction(inst) 18292 } else { 18293 c.adderror(err) 18294 } 18295} 18296 18297// VFMSUB132SS: Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values. 18298// 18299// Forms: 18300// 18301// VFMSUB132SS xmm xmm xmm 18302// VFMSUB132SS m32 xmm xmm 18303// Construct and append a VFMSUB132SS instruction to the active function. 18304// Operates on the global context. 18305func VFMSUB132SS(mx, x, x1 operand.Op) { ctx.VFMSUB132SS(mx, x, x1) } 18306 18307// VFMSUB213PD: Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values. 18308// 18309// Forms: 18310// 18311// VFMSUB213PD xmm xmm xmm 18312// VFMSUB213PD m128 xmm xmm 18313// VFMSUB213PD ymm ymm ymm 18314// VFMSUB213PD m256 ymm ymm 18315// Construct and append a VFMSUB213PD instruction to the active function. 18316func (c *Context) VFMSUB213PD(mxy, xy, xy1 operand.Op) { 18317 if inst, err := x86.VFMSUB213PD(mxy, xy, xy1); err == nil { 18318 c.Instruction(inst) 18319 } else { 18320 c.adderror(err) 18321 } 18322} 18323 18324// VFMSUB213PD: Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values. 18325// 18326// Forms: 18327// 18328// VFMSUB213PD xmm xmm xmm 18329// VFMSUB213PD m128 xmm xmm 18330// VFMSUB213PD ymm ymm ymm 18331// VFMSUB213PD m256 ymm ymm 18332// Construct and append a VFMSUB213PD instruction to the active function. 18333// Operates on the global context. 18334func VFMSUB213PD(mxy, xy, xy1 operand.Op) { ctx.VFMSUB213PD(mxy, xy, xy1) } 18335 18336// VFMSUB213PS: Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values. 18337// 18338// Forms: 18339// 18340// VFMSUB213PS xmm xmm xmm 18341// VFMSUB213PS m128 xmm xmm 18342// VFMSUB213PS ymm ymm ymm 18343// VFMSUB213PS m256 ymm ymm 18344// Construct and append a VFMSUB213PS instruction to the active function. 18345func (c *Context) VFMSUB213PS(mxy, xy, xy1 operand.Op) { 18346 if inst, err := x86.VFMSUB213PS(mxy, xy, xy1); err == nil { 18347 c.Instruction(inst) 18348 } else { 18349 c.adderror(err) 18350 } 18351} 18352 18353// VFMSUB213PS: Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values. 18354// 18355// Forms: 18356// 18357// VFMSUB213PS xmm xmm xmm 18358// VFMSUB213PS m128 xmm xmm 18359// VFMSUB213PS ymm ymm ymm 18360// VFMSUB213PS m256 ymm ymm 18361// Construct and append a VFMSUB213PS instruction to the active function. 18362// Operates on the global context. 18363func VFMSUB213PS(mxy, xy, xy1 operand.Op) { ctx.VFMSUB213PS(mxy, xy, xy1) } 18364 18365// VFMSUB213SD: Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values. 18366// 18367// Forms: 18368// 18369// VFMSUB213SD xmm xmm xmm 18370// VFMSUB213SD m64 xmm xmm 18371// Construct and append a VFMSUB213SD instruction to the active function. 18372func (c *Context) VFMSUB213SD(mx, x, x1 operand.Op) { 18373 if inst, err := x86.VFMSUB213SD(mx, x, x1); err == nil { 18374 c.Instruction(inst) 18375 } else { 18376 c.adderror(err) 18377 } 18378} 18379 18380// VFMSUB213SD: Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values. 18381// 18382// Forms: 18383// 18384// VFMSUB213SD xmm xmm xmm 18385// VFMSUB213SD m64 xmm xmm 18386// Construct and append a VFMSUB213SD instruction to the active function. 18387// Operates on the global context. 18388func VFMSUB213SD(mx, x, x1 operand.Op) { ctx.VFMSUB213SD(mx, x, x1) } 18389 18390// VFMSUB213SS: Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values. 18391// 18392// Forms: 18393// 18394// VFMSUB213SS xmm xmm xmm 18395// VFMSUB213SS m32 xmm xmm 18396// Construct and append a VFMSUB213SS instruction to the active function. 18397func (c *Context) VFMSUB213SS(mx, x, x1 operand.Op) { 18398 if inst, err := x86.VFMSUB213SS(mx, x, x1); err == nil { 18399 c.Instruction(inst) 18400 } else { 18401 c.adderror(err) 18402 } 18403} 18404 18405// VFMSUB213SS: Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values. 18406// 18407// Forms: 18408// 18409// VFMSUB213SS xmm xmm xmm 18410// VFMSUB213SS m32 xmm xmm 18411// Construct and append a VFMSUB213SS instruction to the active function. 18412// Operates on the global context. 18413func VFMSUB213SS(mx, x, x1 operand.Op) { ctx.VFMSUB213SS(mx, x, x1) } 18414 18415// VFMSUB231PD: Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values. 18416// 18417// Forms: 18418// 18419// VFMSUB231PD xmm xmm xmm 18420// VFMSUB231PD m128 xmm xmm 18421// VFMSUB231PD ymm ymm ymm 18422// VFMSUB231PD m256 ymm ymm 18423// Construct and append a VFMSUB231PD instruction to the active function. 18424func (c *Context) VFMSUB231PD(mxy, xy, xy1 operand.Op) { 18425 if inst, err := x86.VFMSUB231PD(mxy, xy, xy1); err == nil { 18426 c.Instruction(inst) 18427 } else { 18428 c.adderror(err) 18429 } 18430} 18431 18432// VFMSUB231PD: Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values. 18433// 18434// Forms: 18435// 18436// VFMSUB231PD xmm xmm xmm 18437// VFMSUB231PD m128 xmm xmm 18438// VFMSUB231PD ymm ymm ymm 18439// VFMSUB231PD m256 ymm ymm 18440// Construct and append a VFMSUB231PD instruction to the active function. 18441// Operates on the global context. 18442func VFMSUB231PD(mxy, xy, xy1 operand.Op) { ctx.VFMSUB231PD(mxy, xy, xy1) } 18443 18444// VFMSUB231PS: Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values. 18445// 18446// Forms: 18447// 18448// VFMSUB231PS xmm xmm xmm 18449// VFMSUB231PS m128 xmm xmm 18450// VFMSUB231PS ymm ymm ymm 18451// VFMSUB231PS m256 ymm ymm 18452// Construct and append a VFMSUB231PS instruction to the active function. 18453func (c *Context) VFMSUB231PS(mxy, xy, xy1 operand.Op) { 18454 if inst, err := x86.VFMSUB231PS(mxy, xy, xy1); err == nil { 18455 c.Instruction(inst) 18456 } else { 18457 c.adderror(err) 18458 } 18459} 18460 18461// VFMSUB231PS: Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values. 18462// 18463// Forms: 18464// 18465// VFMSUB231PS xmm xmm xmm 18466// VFMSUB231PS m128 xmm xmm 18467// VFMSUB231PS ymm ymm ymm 18468// VFMSUB231PS m256 ymm ymm 18469// Construct and append a VFMSUB231PS instruction to the active function. 18470// Operates on the global context. 18471func VFMSUB231PS(mxy, xy, xy1 operand.Op) { ctx.VFMSUB231PS(mxy, xy, xy1) } 18472 18473// VFMSUB231SD: Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values. 18474// 18475// Forms: 18476// 18477// VFMSUB231SD xmm xmm xmm 18478// VFMSUB231SD m64 xmm xmm 18479// Construct and append a VFMSUB231SD instruction to the active function. 18480func (c *Context) VFMSUB231SD(mx, x, x1 operand.Op) { 18481 if inst, err := x86.VFMSUB231SD(mx, x, x1); err == nil { 18482 c.Instruction(inst) 18483 } else { 18484 c.adderror(err) 18485 } 18486} 18487 18488// VFMSUB231SD: Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values. 18489// 18490// Forms: 18491// 18492// VFMSUB231SD xmm xmm xmm 18493// VFMSUB231SD m64 xmm xmm 18494// Construct and append a VFMSUB231SD instruction to the active function. 18495// Operates on the global context. 18496func VFMSUB231SD(mx, x, x1 operand.Op) { ctx.VFMSUB231SD(mx, x, x1) } 18497 18498// VFMSUB231SS: Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values. 18499// 18500// Forms: 18501// 18502// VFMSUB231SS xmm xmm xmm 18503// VFMSUB231SS m32 xmm xmm 18504// Construct and append a VFMSUB231SS instruction to the active function. 18505func (c *Context) VFMSUB231SS(mx, x, x1 operand.Op) { 18506 if inst, err := x86.VFMSUB231SS(mx, x, x1); err == nil { 18507 c.Instruction(inst) 18508 } else { 18509 c.adderror(err) 18510 } 18511} 18512 18513// VFMSUB231SS: Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values. 18514// 18515// Forms: 18516// 18517// VFMSUB231SS xmm xmm xmm 18518// VFMSUB231SS m32 xmm xmm 18519// Construct and append a VFMSUB231SS instruction to the active function. 18520// Operates on the global context. 18521func VFMSUB231SS(mx, x, x1 operand.Op) { ctx.VFMSUB231SS(mx, x, x1) } 18522 18523// VFMSUBADD132PD: Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values. 18524// 18525// Forms: 18526// 18527// VFMSUBADD132PD xmm xmm xmm 18528// VFMSUBADD132PD m128 xmm xmm 18529// VFMSUBADD132PD ymm ymm ymm 18530// VFMSUBADD132PD m256 ymm ymm 18531// Construct and append a VFMSUBADD132PD instruction to the active function. 18532func (c *Context) VFMSUBADD132PD(mxy, xy, xy1 operand.Op) { 18533 if inst, err := x86.VFMSUBADD132PD(mxy, xy, xy1); err == nil { 18534 c.Instruction(inst) 18535 } else { 18536 c.adderror(err) 18537 } 18538} 18539 18540// VFMSUBADD132PD: Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values. 18541// 18542// Forms: 18543// 18544// VFMSUBADD132PD xmm xmm xmm 18545// VFMSUBADD132PD m128 xmm xmm 18546// VFMSUBADD132PD ymm ymm ymm 18547// VFMSUBADD132PD m256 ymm ymm 18548// Construct and append a VFMSUBADD132PD instruction to the active function. 18549// Operates on the global context. 18550func VFMSUBADD132PD(mxy, xy, xy1 operand.Op) { ctx.VFMSUBADD132PD(mxy, xy, xy1) } 18551 18552// VFMSUBADD132PS: Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values. 18553// 18554// Forms: 18555// 18556// VFMSUBADD132PS xmm xmm xmm 18557// VFMSUBADD132PS m128 xmm xmm 18558// VFMSUBADD132PS ymm ymm ymm 18559// VFMSUBADD132PS m256 ymm ymm 18560// Construct and append a VFMSUBADD132PS instruction to the active function. 18561func (c *Context) VFMSUBADD132PS(mxy, xy, xy1 operand.Op) { 18562 if inst, err := x86.VFMSUBADD132PS(mxy, xy, xy1); err == nil { 18563 c.Instruction(inst) 18564 } else { 18565 c.adderror(err) 18566 } 18567} 18568 18569// VFMSUBADD132PS: Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values. 18570// 18571// Forms: 18572// 18573// VFMSUBADD132PS xmm xmm xmm 18574// VFMSUBADD132PS m128 xmm xmm 18575// VFMSUBADD132PS ymm ymm ymm 18576// VFMSUBADD132PS m256 ymm ymm 18577// Construct and append a VFMSUBADD132PS instruction to the active function. 18578// Operates on the global context. 18579func VFMSUBADD132PS(mxy, xy, xy1 operand.Op) { ctx.VFMSUBADD132PS(mxy, xy, xy1) } 18580 18581// VFMSUBADD213PD: Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values. 18582// 18583// Forms: 18584// 18585// VFMSUBADD213PD xmm xmm xmm 18586// VFMSUBADD213PD m128 xmm xmm 18587// VFMSUBADD213PD ymm ymm ymm 18588// VFMSUBADD213PD m256 ymm ymm 18589// Construct and append a VFMSUBADD213PD instruction to the active function. 18590func (c *Context) VFMSUBADD213PD(mxy, xy, xy1 operand.Op) { 18591 if inst, err := x86.VFMSUBADD213PD(mxy, xy, xy1); err == nil { 18592 c.Instruction(inst) 18593 } else { 18594 c.adderror(err) 18595 } 18596} 18597 18598// VFMSUBADD213PD: Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values. 18599// 18600// Forms: 18601// 18602// VFMSUBADD213PD xmm xmm xmm 18603// VFMSUBADD213PD m128 xmm xmm 18604// VFMSUBADD213PD ymm ymm ymm 18605// VFMSUBADD213PD m256 ymm ymm 18606// Construct and append a VFMSUBADD213PD instruction to the active function. 18607// Operates on the global context. 18608func VFMSUBADD213PD(mxy, xy, xy1 operand.Op) { ctx.VFMSUBADD213PD(mxy, xy, xy1) } 18609 18610// VFMSUBADD213PS: Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values. 18611// 18612// Forms: 18613// 18614// VFMSUBADD213PS xmm xmm xmm 18615// VFMSUBADD213PS m128 xmm xmm 18616// VFMSUBADD213PS ymm ymm ymm 18617// VFMSUBADD213PS m256 ymm ymm 18618// Construct and append a VFMSUBADD213PS instruction to the active function. 18619func (c *Context) VFMSUBADD213PS(mxy, xy, xy1 operand.Op) { 18620 if inst, err := x86.VFMSUBADD213PS(mxy, xy, xy1); err == nil { 18621 c.Instruction(inst) 18622 } else { 18623 c.adderror(err) 18624 } 18625} 18626 18627// VFMSUBADD213PS: Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values. 18628// 18629// Forms: 18630// 18631// VFMSUBADD213PS xmm xmm xmm 18632// VFMSUBADD213PS m128 xmm xmm 18633// VFMSUBADD213PS ymm ymm ymm 18634// VFMSUBADD213PS m256 ymm ymm 18635// Construct and append a VFMSUBADD213PS instruction to the active function. 18636// Operates on the global context. 18637func VFMSUBADD213PS(mxy, xy, xy1 operand.Op) { ctx.VFMSUBADD213PS(mxy, xy, xy1) } 18638 18639// VFMSUBADD231PD: Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values. 18640// 18641// Forms: 18642// 18643// VFMSUBADD231PD xmm xmm xmm 18644// VFMSUBADD231PD m128 xmm xmm 18645// VFMSUBADD231PD ymm ymm ymm 18646// VFMSUBADD231PD m256 ymm ymm 18647// Construct and append a VFMSUBADD231PD instruction to the active function. 18648func (c *Context) VFMSUBADD231PD(mxy, xy, xy1 operand.Op) { 18649 if inst, err := x86.VFMSUBADD231PD(mxy, xy, xy1); err == nil { 18650 c.Instruction(inst) 18651 } else { 18652 c.adderror(err) 18653 } 18654} 18655 18656// VFMSUBADD231PD: Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values. 18657// 18658// Forms: 18659// 18660// VFMSUBADD231PD xmm xmm xmm 18661// VFMSUBADD231PD m128 xmm xmm 18662// VFMSUBADD231PD ymm ymm ymm 18663// VFMSUBADD231PD m256 ymm ymm 18664// Construct and append a VFMSUBADD231PD instruction to the active function. 18665// Operates on the global context. 18666func VFMSUBADD231PD(mxy, xy, xy1 operand.Op) { ctx.VFMSUBADD231PD(mxy, xy, xy1) } 18667 18668// VFMSUBADD231PS: Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values. 18669// 18670// Forms: 18671// 18672// VFMSUBADD231PS xmm xmm xmm 18673// VFMSUBADD231PS m128 xmm xmm 18674// VFMSUBADD231PS ymm ymm ymm 18675// VFMSUBADD231PS m256 ymm ymm 18676// Construct and append a VFMSUBADD231PS instruction to the active function. 18677func (c *Context) VFMSUBADD231PS(mxy, xy, xy1 operand.Op) { 18678 if inst, err := x86.VFMSUBADD231PS(mxy, xy, xy1); err == nil { 18679 c.Instruction(inst) 18680 } else { 18681 c.adderror(err) 18682 } 18683} 18684 18685// VFMSUBADD231PS: Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values. 18686// 18687// Forms: 18688// 18689// VFMSUBADD231PS xmm xmm xmm 18690// VFMSUBADD231PS m128 xmm xmm 18691// VFMSUBADD231PS ymm ymm ymm 18692// VFMSUBADD231PS m256 ymm ymm 18693// Construct and append a VFMSUBADD231PS instruction to the active function. 18694// Operates on the global context. 18695func VFMSUBADD231PS(mxy, xy, xy1 operand.Op) { ctx.VFMSUBADD231PS(mxy, xy, xy1) } 18696 18697// VFNMADD132PD: Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values. 18698// 18699// Forms: 18700// 18701// VFNMADD132PD xmm xmm xmm 18702// VFNMADD132PD m128 xmm xmm 18703// VFNMADD132PD ymm ymm ymm 18704// VFNMADD132PD m256 ymm ymm 18705// Construct and append a VFNMADD132PD instruction to the active function. 18706func (c *Context) VFNMADD132PD(mxy, xy, xy1 operand.Op) { 18707 if inst, err := x86.VFNMADD132PD(mxy, xy, xy1); err == nil { 18708 c.Instruction(inst) 18709 } else { 18710 c.adderror(err) 18711 } 18712} 18713 18714// VFNMADD132PD: Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values. 18715// 18716// Forms: 18717// 18718// VFNMADD132PD xmm xmm xmm 18719// VFNMADD132PD m128 xmm xmm 18720// VFNMADD132PD ymm ymm ymm 18721// VFNMADD132PD m256 ymm ymm 18722// Construct and append a VFNMADD132PD instruction to the active function. 18723// Operates on the global context. 18724func VFNMADD132PD(mxy, xy, xy1 operand.Op) { ctx.VFNMADD132PD(mxy, xy, xy1) } 18725 18726// VFNMADD132PS: Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values. 18727// 18728// Forms: 18729// 18730// VFNMADD132PS xmm xmm xmm 18731// VFNMADD132PS m128 xmm xmm 18732// VFNMADD132PS ymm ymm ymm 18733// VFNMADD132PS m256 ymm ymm 18734// Construct and append a VFNMADD132PS instruction to the active function. 18735func (c *Context) VFNMADD132PS(mxy, xy, xy1 operand.Op) { 18736 if inst, err := x86.VFNMADD132PS(mxy, xy, xy1); err == nil { 18737 c.Instruction(inst) 18738 } else { 18739 c.adderror(err) 18740 } 18741} 18742 18743// VFNMADD132PS: Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values. 18744// 18745// Forms: 18746// 18747// VFNMADD132PS xmm xmm xmm 18748// VFNMADD132PS m128 xmm xmm 18749// VFNMADD132PS ymm ymm ymm 18750// VFNMADD132PS m256 ymm ymm 18751// Construct and append a VFNMADD132PS instruction to the active function. 18752// Operates on the global context. 18753func VFNMADD132PS(mxy, xy, xy1 operand.Op) { ctx.VFNMADD132PS(mxy, xy, xy1) } 18754 18755// VFNMADD132SD: Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values. 18756// 18757// Forms: 18758// 18759// VFNMADD132SD xmm xmm xmm 18760// VFNMADD132SD m64 xmm xmm 18761// Construct and append a VFNMADD132SD instruction to the active function. 18762func (c *Context) VFNMADD132SD(mx, x, x1 operand.Op) { 18763 if inst, err := x86.VFNMADD132SD(mx, x, x1); err == nil { 18764 c.Instruction(inst) 18765 } else { 18766 c.adderror(err) 18767 } 18768} 18769 18770// VFNMADD132SD: Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values. 18771// 18772// Forms: 18773// 18774// VFNMADD132SD xmm xmm xmm 18775// VFNMADD132SD m64 xmm xmm 18776// Construct and append a VFNMADD132SD instruction to the active function. 18777// Operates on the global context. 18778func VFNMADD132SD(mx, x, x1 operand.Op) { ctx.VFNMADD132SD(mx, x, x1) } 18779 18780// VFNMADD132SS: Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values. 18781// 18782// Forms: 18783// 18784// VFNMADD132SS xmm xmm xmm 18785// VFNMADD132SS m32 xmm xmm 18786// Construct and append a VFNMADD132SS instruction to the active function. 18787func (c *Context) VFNMADD132SS(mx, x, x1 operand.Op) { 18788 if inst, err := x86.VFNMADD132SS(mx, x, x1); err == nil { 18789 c.Instruction(inst) 18790 } else { 18791 c.adderror(err) 18792 } 18793} 18794 18795// VFNMADD132SS: Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values. 18796// 18797// Forms: 18798// 18799// VFNMADD132SS xmm xmm xmm 18800// VFNMADD132SS m32 xmm xmm 18801// Construct and append a VFNMADD132SS instruction to the active function. 18802// Operates on the global context. 18803func VFNMADD132SS(mx, x, x1 operand.Op) { ctx.VFNMADD132SS(mx, x, x1) } 18804 18805// VFNMADD213PD: Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values. 18806// 18807// Forms: 18808// 18809// VFNMADD213PD xmm xmm xmm 18810// VFNMADD213PD m128 xmm xmm 18811// VFNMADD213PD ymm ymm ymm 18812// VFNMADD213PD m256 ymm ymm 18813// Construct and append a VFNMADD213PD instruction to the active function. 18814func (c *Context) VFNMADD213PD(mxy, xy, xy1 operand.Op) { 18815 if inst, err := x86.VFNMADD213PD(mxy, xy, xy1); err == nil { 18816 c.Instruction(inst) 18817 } else { 18818 c.adderror(err) 18819 } 18820} 18821 18822// VFNMADD213PD: Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values. 18823// 18824// Forms: 18825// 18826// VFNMADD213PD xmm xmm xmm 18827// VFNMADD213PD m128 xmm xmm 18828// VFNMADD213PD ymm ymm ymm 18829// VFNMADD213PD m256 ymm ymm 18830// Construct and append a VFNMADD213PD instruction to the active function. 18831// Operates on the global context. 18832func VFNMADD213PD(mxy, xy, xy1 operand.Op) { ctx.VFNMADD213PD(mxy, xy, xy1) } 18833 18834// VFNMADD213PS: Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values. 18835// 18836// Forms: 18837// 18838// VFNMADD213PS xmm xmm xmm 18839// VFNMADD213PS m128 xmm xmm 18840// VFNMADD213PS ymm ymm ymm 18841// VFNMADD213PS m256 ymm ymm 18842// Construct and append a VFNMADD213PS instruction to the active function. 18843func (c *Context) VFNMADD213PS(mxy, xy, xy1 operand.Op) { 18844 if inst, err := x86.VFNMADD213PS(mxy, xy, xy1); err == nil { 18845 c.Instruction(inst) 18846 } else { 18847 c.adderror(err) 18848 } 18849} 18850 18851// VFNMADD213PS: Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values. 18852// 18853// Forms: 18854// 18855// VFNMADD213PS xmm xmm xmm 18856// VFNMADD213PS m128 xmm xmm 18857// VFNMADD213PS ymm ymm ymm 18858// VFNMADD213PS m256 ymm ymm 18859// Construct and append a VFNMADD213PS instruction to the active function. 18860// Operates on the global context. 18861func VFNMADD213PS(mxy, xy, xy1 operand.Op) { ctx.VFNMADD213PS(mxy, xy, xy1) } 18862 18863// VFNMADD213SD: Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values. 18864// 18865// Forms: 18866// 18867// VFNMADD213SD xmm xmm xmm 18868// VFNMADD213SD m64 xmm xmm 18869// Construct and append a VFNMADD213SD instruction to the active function. 18870func (c *Context) VFNMADD213SD(mx, x, x1 operand.Op) { 18871 if inst, err := x86.VFNMADD213SD(mx, x, x1); err == nil { 18872 c.Instruction(inst) 18873 } else { 18874 c.adderror(err) 18875 } 18876} 18877 18878// VFNMADD213SD: Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values. 18879// 18880// Forms: 18881// 18882// VFNMADD213SD xmm xmm xmm 18883// VFNMADD213SD m64 xmm xmm 18884// Construct and append a VFNMADD213SD instruction to the active function. 18885// Operates on the global context. 18886func VFNMADD213SD(mx, x, x1 operand.Op) { ctx.VFNMADD213SD(mx, x, x1) } 18887 18888// VFNMADD213SS: Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values. 18889// 18890// Forms: 18891// 18892// VFNMADD213SS xmm xmm xmm 18893// VFNMADD213SS m32 xmm xmm 18894// Construct and append a VFNMADD213SS instruction to the active function. 18895func (c *Context) VFNMADD213SS(mx, x, x1 operand.Op) { 18896 if inst, err := x86.VFNMADD213SS(mx, x, x1); err == nil { 18897 c.Instruction(inst) 18898 } else { 18899 c.adderror(err) 18900 } 18901} 18902 18903// VFNMADD213SS: Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values. 18904// 18905// Forms: 18906// 18907// VFNMADD213SS xmm xmm xmm 18908// VFNMADD213SS m32 xmm xmm 18909// Construct and append a VFNMADD213SS instruction to the active function. 18910// Operates on the global context. 18911func VFNMADD213SS(mx, x, x1 operand.Op) { ctx.VFNMADD213SS(mx, x, x1) } 18912 18913// VFNMADD231PD: Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values. 18914// 18915// Forms: 18916// 18917// VFNMADD231PD xmm xmm xmm 18918// VFNMADD231PD m128 xmm xmm 18919// VFNMADD231PD ymm ymm ymm 18920// VFNMADD231PD m256 ymm ymm 18921// Construct and append a VFNMADD231PD instruction to the active function. 18922func (c *Context) VFNMADD231PD(mxy, xy, xy1 operand.Op) { 18923 if inst, err := x86.VFNMADD231PD(mxy, xy, xy1); err == nil { 18924 c.Instruction(inst) 18925 } else { 18926 c.adderror(err) 18927 } 18928} 18929 18930// VFNMADD231PD: Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values. 18931// 18932// Forms: 18933// 18934// VFNMADD231PD xmm xmm xmm 18935// VFNMADD231PD m128 xmm xmm 18936// VFNMADD231PD ymm ymm ymm 18937// VFNMADD231PD m256 ymm ymm 18938// Construct and append a VFNMADD231PD instruction to the active function. 18939// Operates on the global context. 18940func VFNMADD231PD(mxy, xy, xy1 operand.Op) { ctx.VFNMADD231PD(mxy, xy, xy1) } 18941 18942// VFNMADD231PS: Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values. 18943// 18944// Forms: 18945// 18946// VFNMADD231PS xmm xmm xmm 18947// VFNMADD231PS m128 xmm xmm 18948// VFNMADD231PS ymm ymm ymm 18949// VFNMADD231PS m256 ymm ymm 18950// Construct and append a VFNMADD231PS instruction to the active function. 18951func (c *Context) VFNMADD231PS(mxy, xy, xy1 operand.Op) { 18952 if inst, err := x86.VFNMADD231PS(mxy, xy, xy1); err == nil { 18953 c.Instruction(inst) 18954 } else { 18955 c.adderror(err) 18956 } 18957} 18958 18959// VFNMADD231PS: Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values. 18960// 18961// Forms: 18962// 18963// VFNMADD231PS xmm xmm xmm 18964// VFNMADD231PS m128 xmm xmm 18965// VFNMADD231PS ymm ymm ymm 18966// VFNMADD231PS m256 ymm ymm 18967// Construct and append a VFNMADD231PS instruction to the active function. 18968// Operates on the global context. 18969func VFNMADD231PS(mxy, xy, xy1 operand.Op) { ctx.VFNMADD231PS(mxy, xy, xy1) } 18970 18971// VFNMADD231SD: Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values. 18972// 18973// Forms: 18974// 18975// VFNMADD231SD xmm xmm xmm 18976// VFNMADD231SD m64 xmm xmm 18977// Construct and append a VFNMADD231SD instruction to the active function. 18978func (c *Context) VFNMADD231SD(mx, x, x1 operand.Op) { 18979 if inst, err := x86.VFNMADD231SD(mx, x, x1); err == nil { 18980 c.Instruction(inst) 18981 } else { 18982 c.adderror(err) 18983 } 18984} 18985 18986// VFNMADD231SD: Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values. 18987// 18988// Forms: 18989// 18990// VFNMADD231SD xmm xmm xmm 18991// VFNMADD231SD m64 xmm xmm 18992// Construct and append a VFNMADD231SD instruction to the active function. 18993// Operates on the global context. 18994func VFNMADD231SD(mx, x, x1 operand.Op) { ctx.VFNMADD231SD(mx, x, x1) } 18995 18996// VFNMADD231SS: Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values. 18997// 18998// Forms: 18999// 19000// VFNMADD231SS xmm xmm xmm 19001// VFNMADD231SS m32 xmm xmm 19002// Construct and append a VFNMADD231SS instruction to the active function. 19003func (c *Context) VFNMADD231SS(mx, x, x1 operand.Op) { 19004 if inst, err := x86.VFNMADD231SS(mx, x, x1); err == nil { 19005 c.Instruction(inst) 19006 } else { 19007 c.adderror(err) 19008 } 19009} 19010 19011// VFNMADD231SS: Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values. 19012// 19013// Forms: 19014// 19015// VFNMADD231SS xmm xmm xmm 19016// VFNMADD231SS m32 xmm xmm 19017// Construct and append a VFNMADD231SS instruction to the active function. 19018// Operates on the global context. 19019func VFNMADD231SS(mx, x, x1 operand.Op) { ctx.VFNMADD231SS(mx, x, x1) } 19020 19021// VFNMSUB132PD: Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values. 19022// 19023// Forms: 19024// 19025// VFNMSUB132PD xmm xmm xmm 19026// VFNMSUB132PD m128 xmm xmm 19027// VFNMSUB132PD ymm ymm ymm 19028// VFNMSUB132PD m256 ymm ymm 19029// Construct and append a VFNMSUB132PD instruction to the active function. 19030func (c *Context) VFNMSUB132PD(mxy, xy, xy1 operand.Op) { 19031 if inst, err := x86.VFNMSUB132PD(mxy, xy, xy1); err == nil { 19032 c.Instruction(inst) 19033 } else { 19034 c.adderror(err) 19035 } 19036} 19037 19038// VFNMSUB132PD: Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values. 19039// 19040// Forms: 19041// 19042// VFNMSUB132PD xmm xmm xmm 19043// VFNMSUB132PD m128 xmm xmm 19044// VFNMSUB132PD ymm ymm ymm 19045// VFNMSUB132PD m256 ymm ymm 19046// Construct and append a VFNMSUB132PD instruction to the active function. 19047// Operates on the global context. 19048func VFNMSUB132PD(mxy, xy, xy1 operand.Op) { ctx.VFNMSUB132PD(mxy, xy, xy1) } 19049 19050// VFNMSUB132PS: Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values. 19051// 19052// Forms: 19053// 19054// VFNMSUB132PS xmm xmm xmm 19055// VFNMSUB132PS m128 xmm xmm 19056// VFNMSUB132PS ymm ymm ymm 19057// VFNMSUB132PS m256 ymm ymm 19058// Construct and append a VFNMSUB132PS instruction to the active function. 19059func (c *Context) VFNMSUB132PS(mxy, xy, xy1 operand.Op) { 19060 if inst, err := x86.VFNMSUB132PS(mxy, xy, xy1); err == nil { 19061 c.Instruction(inst) 19062 } else { 19063 c.adderror(err) 19064 } 19065} 19066 19067// VFNMSUB132PS: Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values. 19068// 19069// Forms: 19070// 19071// VFNMSUB132PS xmm xmm xmm 19072// VFNMSUB132PS m128 xmm xmm 19073// VFNMSUB132PS ymm ymm ymm 19074// VFNMSUB132PS m256 ymm ymm 19075// Construct and append a VFNMSUB132PS instruction to the active function. 19076// Operates on the global context. 19077func VFNMSUB132PS(mxy, xy, xy1 operand.Op) { ctx.VFNMSUB132PS(mxy, xy, xy1) } 19078 19079// VFNMSUB132SD: Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values. 19080// 19081// Forms: 19082// 19083// VFNMSUB132SD xmm xmm xmm 19084// VFNMSUB132SD m64 xmm xmm 19085// Construct and append a VFNMSUB132SD instruction to the active function. 19086func (c *Context) VFNMSUB132SD(mx, x, x1 operand.Op) { 19087 if inst, err := x86.VFNMSUB132SD(mx, x, x1); err == nil { 19088 c.Instruction(inst) 19089 } else { 19090 c.adderror(err) 19091 } 19092} 19093 19094// VFNMSUB132SD: Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values. 19095// 19096// Forms: 19097// 19098// VFNMSUB132SD xmm xmm xmm 19099// VFNMSUB132SD m64 xmm xmm 19100// Construct and append a VFNMSUB132SD instruction to the active function. 19101// Operates on the global context. 19102func VFNMSUB132SD(mx, x, x1 operand.Op) { ctx.VFNMSUB132SD(mx, x, x1) } 19103 19104// VFNMSUB132SS: Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values. 19105// 19106// Forms: 19107// 19108// VFNMSUB132SS xmm xmm xmm 19109// VFNMSUB132SS m32 xmm xmm 19110// Construct and append a VFNMSUB132SS instruction to the active function. 19111func (c *Context) VFNMSUB132SS(mx, x, x1 operand.Op) { 19112 if inst, err := x86.VFNMSUB132SS(mx, x, x1); err == nil { 19113 c.Instruction(inst) 19114 } else { 19115 c.adderror(err) 19116 } 19117} 19118 19119// VFNMSUB132SS: Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values. 19120// 19121// Forms: 19122// 19123// VFNMSUB132SS xmm xmm xmm 19124// VFNMSUB132SS m32 xmm xmm 19125// Construct and append a VFNMSUB132SS instruction to the active function. 19126// Operates on the global context. 19127func VFNMSUB132SS(mx, x, x1 operand.Op) { ctx.VFNMSUB132SS(mx, x, x1) } 19128 19129// VFNMSUB213PD: Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values. 19130// 19131// Forms: 19132// 19133// VFNMSUB213PD xmm xmm xmm 19134// VFNMSUB213PD m128 xmm xmm 19135// VFNMSUB213PD ymm ymm ymm 19136// VFNMSUB213PD m256 ymm ymm 19137// Construct and append a VFNMSUB213PD instruction to the active function. 19138func (c *Context) VFNMSUB213PD(mxy, xy, xy1 operand.Op) { 19139 if inst, err := x86.VFNMSUB213PD(mxy, xy, xy1); err == nil { 19140 c.Instruction(inst) 19141 } else { 19142 c.adderror(err) 19143 } 19144} 19145 19146// VFNMSUB213PD: Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values. 19147// 19148// Forms: 19149// 19150// VFNMSUB213PD xmm xmm xmm 19151// VFNMSUB213PD m128 xmm xmm 19152// VFNMSUB213PD ymm ymm ymm 19153// VFNMSUB213PD m256 ymm ymm 19154// Construct and append a VFNMSUB213PD instruction to the active function. 19155// Operates on the global context. 19156func VFNMSUB213PD(mxy, xy, xy1 operand.Op) { ctx.VFNMSUB213PD(mxy, xy, xy1) } 19157 19158// VFNMSUB213PS: Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values. 19159// 19160// Forms: 19161// 19162// VFNMSUB213PS xmm xmm xmm 19163// VFNMSUB213PS m128 xmm xmm 19164// VFNMSUB213PS ymm ymm ymm 19165// VFNMSUB213PS m256 ymm ymm 19166// Construct and append a VFNMSUB213PS instruction to the active function. 19167func (c *Context) VFNMSUB213PS(mxy, xy, xy1 operand.Op) { 19168 if inst, err := x86.VFNMSUB213PS(mxy, xy, xy1); err == nil { 19169 c.Instruction(inst) 19170 } else { 19171 c.adderror(err) 19172 } 19173} 19174 19175// VFNMSUB213PS: Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values. 19176// 19177// Forms: 19178// 19179// VFNMSUB213PS xmm xmm xmm 19180// VFNMSUB213PS m128 xmm xmm 19181// VFNMSUB213PS ymm ymm ymm 19182// VFNMSUB213PS m256 ymm ymm 19183// Construct and append a VFNMSUB213PS instruction to the active function. 19184// Operates on the global context. 19185func VFNMSUB213PS(mxy, xy, xy1 operand.Op) { ctx.VFNMSUB213PS(mxy, xy, xy1) } 19186 19187// VFNMSUB213SD: Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values. 19188// 19189// Forms: 19190// 19191// VFNMSUB213SD xmm xmm xmm 19192// VFNMSUB213SD m64 xmm xmm 19193// Construct and append a VFNMSUB213SD instruction to the active function. 19194func (c *Context) VFNMSUB213SD(mx, x, x1 operand.Op) { 19195 if inst, err := x86.VFNMSUB213SD(mx, x, x1); err == nil { 19196 c.Instruction(inst) 19197 } else { 19198 c.adderror(err) 19199 } 19200} 19201 19202// VFNMSUB213SD: Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values. 19203// 19204// Forms: 19205// 19206// VFNMSUB213SD xmm xmm xmm 19207// VFNMSUB213SD m64 xmm xmm 19208// Construct and append a VFNMSUB213SD instruction to the active function. 19209// Operates on the global context. 19210func VFNMSUB213SD(mx, x, x1 operand.Op) { ctx.VFNMSUB213SD(mx, x, x1) } 19211 19212// VFNMSUB213SS: Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values. 19213// 19214// Forms: 19215// 19216// VFNMSUB213SS xmm xmm xmm 19217// VFNMSUB213SS m32 xmm xmm 19218// Construct and append a VFNMSUB213SS instruction to the active function. 19219func (c *Context) VFNMSUB213SS(mx, x, x1 operand.Op) { 19220 if inst, err := x86.VFNMSUB213SS(mx, x, x1); err == nil { 19221 c.Instruction(inst) 19222 } else { 19223 c.adderror(err) 19224 } 19225} 19226 19227// VFNMSUB213SS: Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values. 19228// 19229// Forms: 19230// 19231// VFNMSUB213SS xmm xmm xmm 19232// VFNMSUB213SS m32 xmm xmm 19233// Construct and append a VFNMSUB213SS instruction to the active function. 19234// Operates on the global context. 19235func VFNMSUB213SS(mx, x, x1 operand.Op) { ctx.VFNMSUB213SS(mx, x, x1) } 19236 19237// VFNMSUB231PD: Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values. 19238// 19239// Forms: 19240// 19241// VFNMSUB231PD xmm xmm xmm 19242// VFNMSUB231PD m128 xmm xmm 19243// VFNMSUB231PD ymm ymm ymm 19244// VFNMSUB231PD m256 ymm ymm 19245// Construct and append a VFNMSUB231PD instruction to the active function. 19246func (c *Context) VFNMSUB231PD(mxy, xy, xy1 operand.Op) { 19247 if inst, err := x86.VFNMSUB231PD(mxy, xy, xy1); err == nil { 19248 c.Instruction(inst) 19249 } else { 19250 c.adderror(err) 19251 } 19252} 19253 19254// VFNMSUB231PD: Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values. 19255// 19256// Forms: 19257// 19258// VFNMSUB231PD xmm xmm xmm 19259// VFNMSUB231PD m128 xmm xmm 19260// VFNMSUB231PD ymm ymm ymm 19261// VFNMSUB231PD m256 ymm ymm 19262// Construct and append a VFNMSUB231PD instruction to the active function. 19263// Operates on the global context. 19264func VFNMSUB231PD(mxy, xy, xy1 operand.Op) { ctx.VFNMSUB231PD(mxy, xy, xy1) } 19265 19266// VFNMSUB231PS: Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values. 19267// 19268// Forms: 19269// 19270// VFNMSUB231PS xmm xmm xmm 19271// VFNMSUB231PS m128 xmm xmm 19272// VFNMSUB231PS ymm ymm ymm 19273// VFNMSUB231PS m256 ymm ymm 19274// Construct and append a VFNMSUB231PS instruction to the active function. 19275func (c *Context) VFNMSUB231PS(mxy, xy, xy1 operand.Op) { 19276 if inst, err := x86.VFNMSUB231PS(mxy, xy, xy1); err == nil { 19277 c.Instruction(inst) 19278 } else { 19279 c.adderror(err) 19280 } 19281} 19282 19283// VFNMSUB231PS: Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values. 19284// 19285// Forms: 19286// 19287// VFNMSUB231PS xmm xmm xmm 19288// VFNMSUB231PS m128 xmm xmm 19289// VFNMSUB231PS ymm ymm ymm 19290// VFNMSUB231PS m256 ymm ymm 19291// Construct and append a VFNMSUB231PS instruction to the active function. 19292// Operates on the global context. 19293func VFNMSUB231PS(mxy, xy, xy1 operand.Op) { ctx.VFNMSUB231PS(mxy, xy, xy1) } 19294 19295// VFNMSUB231SD: Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values. 19296// 19297// Forms: 19298// 19299// VFNMSUB231SD xmm xmm xmm 19300// VFNMSUB231SD m64 xmm xmm 19301// Construct and append a VFNMSUB231SD instruction to the active function. 19302func (c *Context) VFNMSUB231SD(mx, x, x1 operand.Op) { 19303 if inst, err := x86.VFNMSUB231SD(mx, x, x1); err == nil { 19304 c.Instruction(inst) 19305 } else { 19306 c.adderror(err) 19307 } 19308} 19309 19310// VFNMSUB231SD: Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values. 19311// 19312// Forms: 19313// 19314// VFNMSUB231SD xmm xmm xmm 19315// VFNMSUB231SD m64 xmm xmm 19316// Construct and append a VFNMSUB231SD instruction to the active function. 19317// Operates on the global context. 19318func VFNMSUB231SD(mx, x, x1 operand.Op) { ctx.VFNMSUB231SD(mx, x, x1) } 19319 19320// VFNMSUB231SS: Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values. 19321// 19322// Forms: 19323// 19324// VFNMSUB231SS xmm xmm xmm 19325// VFNMSUB231SS m32 xmm xmm 19326// Construct and append a VFNMSUB231SS instruction to the active function. 19327func (c *Context) VFNMSUB231SS(mx, x, x1 operand.Op) { 19328 if inst, err := x86.VFNMSUB231SS(mx, x, x1); err == nil { 19329 c.Instruction(inst) 19330 } else { 19331 c.adderror(err) 19332 } 19333} 19334 19335// VFNMSUB231SS: Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values. 19336// 19337// Forms: 19338// 19339// VFNMSUB231SS xmm xmm xmm 19340// VFNMSUB231SS m32 xmm xmm 19341// Construct and append a VFNMSUB231SS instruction to the active function. 19342// Operates on the global context. 19343func VFNMSUB231SS(mx, x, x1 operand.Op) { ctx.VFNMSUB231SS(mx, x, x1) } 19344 19345// VGATHERDPD: Gather Packed Double-Precision Floating-Point Values Using Signed Doubleword Indices. 19346// 19347// Forms: 19348// 19349// VGATHERDPD xmm vm32x xmm 19350// VGATHERDPD ymm vm32x ymm 19351// Construct and append a VGATHERDPD instruction to the active function. 19352func (c *Context) VGATHERDPD(xy, v, xy1 operand.Op) { 19353 if inst, err := x86.VGATHERDPD(xy, v, xy1); err == nil { 19354 c.Instruction(inst) 19355 } else { 19356 c.adderror(err) 19357 } 19358} 19359 19360// VGATHERDPD: Gather Packed Double-Precision Floating-Point Values Using Signed Doubleword Indices. 19361// 19362// Forms: 19363// 19364// VGATHERDPD xmm vm32x xmm 19365// VGATHERDPD ymm vm32x ymm 19366// Construct and append a VGATHERDPD instruction to the active function. 19367// Operates on the global context. 19368func VGATHERDPD(xy, v, xy1 operand.Op) { ctx.VGATHERDPD(xy, v, xy1) } 19369 19370// VGATHERDPS: Gather Packed Single-Precision Floating-Point Values Using Signed Doubleword Indices. 19371// 19372// Forms: 19373// 19374// VGATHERDPS xmm vm32x xmm 19375// VGATHERDPS ymm vm32y ymm 19376// Construct and append a VGATHERDPS instruction to the active function. 19377func (c *Context) VGATHERDPS(xy, v, xy1 operand.Op) { 19378 if inst, err := x86.VGATHERDPS(xy, v, xy1); err == nil { 19379 c.Instruction(inst) 19380 } else { 19381 c.adderror(err) 19382 } 19383} 19384 19385// VGATHERDPS: Gather Packed Single-Precision Floating-Point Values Using Signed Doubleword Indices. 19386// 19387// Forms: 19388// 19389// VGATHERDPS xmm vm32x xmm 19390// VGATHERDPS ymm vm32y ymm 19391// Construct and append a VGATHERDPS instruction to the active function. 19392// Operates on the global context. 19393func VGATHERDPS(xy, v, xy1 operand.Op) { ctx.VGATHERDPS(xy, v, xy1) } 19394 19395// VGATHERQPD: Gather Packed Double-Precision Floating-Point Values Using Signed Quadword Indices. 19396// 19397// Forms: 19398// 19399// VGATHERQPD xmm vm64x xmm 19400// VGATHERQPD ymm vm64y ymm 19401// Construct and append a VGATHERQPD instruction to the active function. 19402func (c *Context) VGATHERQPD(xy, v, xy1 operand.Op) { 19403 if inst, err := x86.VGATHERQPD(xy, v, xy1); err == nil { 19404 c.Instruction(inst) 19405 } else { 19406 c.adderror(err) 19407 } 19408} 19409 19410// VGATHERQPD: Gather Packed Double-Precision Floating-Point Values Using Signed Quadword Indices. 19411// 19412// Forms: 19413// 19414// VGATHERQPD xmm vm64x xmm 19415// VGATHERQPD ymm vm64y ymm 19416// Construct and append a VGATHERQPD instruction to the active function. 19417// Operates on the global context. 19418func VGATHERQPD(xy, v, xy1 operand.Op) { ctx.VGATHERQPD(xy, v, xy1) } 19419 19420// VGATHERQPS: Gather Packed Single-Precision Floating-Point Values Using Signed Quadword Indices. 19421// 19422// Forms: 19423// 19424// VGATHERQPS xmm vm64x xmm 19425// VGATHERQPS xmm vm64y xmm 19426// Construct and append a VGATHERQPS instruction to the active function. 19427func (c *Context) VGATHERQPS(x, v, x1 operand.Op) { 19428 if inst, err := x86.VGATHERQPS(x, v, x1); err == nil { 19429 c.Instruction(inst) 19430 } else { 19431 c.adderror(err) 19432 } 19433} 19434 19435// VGATHERQPS: Gather Packed Single-Precision Floating-Point Values Using Signed Quadword Indices. 19436// 19437// Forms: 19438// 19439// VGATHERQPS xmm vm64x xmm 19440// VGATHERQPS xmm vm64y xmm 19441// Construct and append a VGATHERQPS instruction to the active function. 19442// Operates on the global context. 19443func VGATHERQPS(x, v, x1 operand.Op) { ctx.VGATHERQPS(x, v, x1) } 19444 19445// VHADDPD: Packed Double-FP Horizontal Add. 19446// 19447// Forms: 19448// 19449// VHADDPD xmm xmm xmm 19450// VHADDPD m128 xmm xmm 19451// VHADDPD ymm ymm ymm 19452// VHADDPD m256 ymm ymm 19453// Construct and append a VHADDPD instruction to the active function. 19454func (c *Context) VHADDPD(mxy, xy, xy1 operand.Op) { 19455 if inst, err := x86.VHADDPD(mxy, xy, xy1); err == nil { 19456 c.Instruction(inst) 19457 } else { 19458 c.adderror(err) 19459 } 19460} 19461 19462// VHADDPD: Packed Double-FP Horizontal Add. 19463// 19464// Forms: 19465// 19466// VHADDPD xmm xmm xmm 19467// VHADDPD m128 xmm xmm 19468// VHADDPD ymm ymm ymm 19469// VHADDPD m256 ymm ymm 19470// Construct and append a VHADDPD instruction to the active function. 19471// Operates on the global context. 19472func VHADDPD(mxy, xy, xy1 operand.Op) { ctx.VHADDPD(mxy, xy, xy1) } 19473 19474// VHADDPS: Packed Single-FP Horizontal Add. 19475// 19476// Forms: 19477// 19478// VHADDPS xmm xmm xmm 19479// VHADDPS m128 xmm xmm 19480// VHADDPS ymm ymm ymm 19481// VHADDPS m256 ymm ymm 19482// Construct and append a VHADDPS instruction to the active function. 19483func (c *Context) VHADDPS(mxy, xy, xy1 operand.Op) { 19484 if inst, err := x86.VHADDPS(mxy, xy, xy1); err == nil { 19485 c.Instruction(inst) 19486 } else { 19487 c.adderror(err) 19488 } 19489} 19490 19491// VHADDPS: Packed Single-FP Horizontal Add. 19492// 19493// Forms: 19494// 19495// VHADDPS xmm xmm xmm 19496// VHADDPS m128 xmm xmm 19497// VHADDPS ymm ymm ymm 19498// VHADDPS m256 ymm ymm 19499// Construct and append a VHADDPS instruction to the active function. 19500// Operates on the global context. 19501func VHADDPS(mxy, xy, xy1 operand.Op) { ctx.VHADDPS(mxy, xy, xy1) } 19502 19503// VHSUBPD: Packed Double-FP Horizontal Subtract. 19504// 19505// Forms: 19506// 19507// VHSUBPD xmm xmm xmm 19508// VHSUBPD m128 xmm xmm 19509// VHSUBPD ymm ymm ymm 19510// VHSUBPD m256 ymm ymm 19511// Construct and append a VHSUBPD instruction to the active function. 19512func (c *Context) VHSUBPD(mxy, xy, xy1 operand.Op) { 19513 if inst, err := x86.VHSUBPD(mxy, xy, xy1); err == nil { 19514 c.Instruction(inst) 19515 } else { 19516 c.adderror(err) 19517 } 19518} 19519 19520// VHSUBPD: Packed Double-FP Horizontal Subtract. 19521// 19522// Forms: 19523// 19524// VHSUBPD xmm xmm xmm 19525// VHSUBPD m128 xmm xmm 19526// VHSUBPD ymm ymm ymm 19527// VHSUBPD m256 ymm ymm 19528// Construct and append a VHSUBPD instruction to the active function. 19529// Operates on the global context. 19530func VHSUBPD(mxy, xy, xy1 operand.Op) { ctx.VHSUBPD(mxy, xy, xy1) } 19531 19532// VHSUBPS: Packed Single-FP Horizontal Subtract. 19533// 19534// Forms: 19535// 19536// VHSUBPS xmm xmm xmm 19537// VHSUBPS m128 xmm xmm 19538// VHSUBPS ymm ymm ymm 19539// VHSUBPS m256 ymm ymm 19540// Construct and append a VHSUBPS instruction to the active function. 19541func (c *Context) VHSUBPS(mxy, xy, xy1 operand.Op) { 19542 if inst, err := x86.VHSUBPS(mxy, xy, xy1); err == nil { 19543 c.Instruction(inst) 19544 } else { 19545 c.adderror(err) 19546 } 19547} 19548 19549// VHSUBPS: Packed Single-FP Horizontal Subtract. 19550// 19551// Forms: 19552// 19553// VHSUBPS xmm xmm xmm 19554// VHSUBPS m128 xmm xmm 19555// VHSUBPS ymm ymm ymm 19556// VHSUBPS m256 ymm ymm 19557// Construct and append a VHSUBPS instruction to the active function. 19558// Operates on the global context. 19559func VHSUBPS(mxy, xy, xy1 operand.Op) { ctx.VHSUBPS(mxy, xy, xy1) } 19560 19561// VINSERTF128: Insert Packed Floating-Point Values. 19562// 19563// Forms: 19564// 19565// VINSERTF128 imm8 xmm ymm ymm 19566// VINSERTF128 imm8 m128 ymm ymm 19567// Construct and append a VINSERTF128 instruction to the active function. 19568func (c *Context) VINSERTF128(i, mx, y, y1 operand.Op) { 19569 if inst, err := x86.VINSERTF128(i, mx, y, y1); err == nil { 19570 c.Instruction(inst) 19571 } else { 19572 c.adderror(err) 19573 } 19574} 19575 19576// VINSERTF128: Insert Packed Floating-Point Values. 19577// 19578// Forms: 19579// 19580// VINSERTF128 imm8 xmm ymm ymm 19581// VINSERTF128 imm8 m128 ymm ymm 19582// Construct and append a VINSERTF128 instruction to the active function. 19583// Operates on the global context. 19584func VINSERTF128(i, mx, y, y1 operand.Op) { ctx.VINSERTF128(i, mx, y, y1) } 19585 19586// VINSERTI128: Insert Packed Integer Values. 19587// 19588// Forms: 19589// 19590// VINSERTI128 imm8 xmm ymm ymm 19591// VINSERTI128 imm8 m128 ymm ymm 19592// Construct and append a VINSERTI128 instruction to the active function. 19593func (c *Context) VINSERTI128(i, mx, y, y1 operand.Op) { 19594 if inst, err := x86.VINSERTI128(i, mx, y, y1); err == nil { 19595 c.Instruction(inst) 19596 } else { 19597 c.adderror(err) 19598 } 19599} 19600 19601// VINSERTI128: Insert Packed Integer Values. 19602// 19603// Forms: 19604// 19605// VINSERTI128 imm8 xmm ymm ymm 19606// VINSERTI128 imm8 m128 ymm ymm 19607// Construct and append a VINSERTI128 instruction to the active function. 19608// Operates on the global context. 19609func VINSERTI128(i, mx, y, y1 operand.Op) { ctx.VINSERTI128(i, mx, y, y1) } 19610 19611// VINSERTPS: Insert Packed Single Precision Floating-Point Value. 19612// 19613// Forms: 19614// 19615// VINSERTPS imm8 xmm xmm xmm 19616// VINSERTPS imm8 m32 xmm xmm 19617// Construct and append a VINSERTPS instruction to the active function. 19618func (c *Context) VINSERTPS(i, mx, x, x1 operand.Op) { 19619 if inst, err := x86.VINSERTPS(i, mx, x, x1); err == nil { 19620 c.Instruction(inst) 19621 } else { 19622 c.adderror(err) 19623 } 19624} 19625 19626// VINSERTPS: Insert Packed Single Precision Floating-Point Value. 19627// 19628// Forms: 19629// 19630// VINSERTPS imm8 xmm xmm xmm 19631// VINSERTPS imm8 m32 xmm xmm 19632// Construct and append a VINSERTPS instruction to the active function. 19633// Operates on the global context. 19634func VINSERTPS(i, mx, x, x1 operand.Op) { ctx.VINSERTPS(i, mx, x, x1) } 19635 19636// VLDDQU: Load Unaligned Integer 128 Bits. 19637// 19638// Forms: 19639// 19640// VLDDQU m128 xmm 19641// VLDDQU m256 ymm 19642// Construct and append a VLDDQU instruction to the active function. 19643func (c *Context) VLDDQU(m, xy operand.Op) { 19644 if inst, err := x86.VLDDQU(m, xy); err == nil { 19645 c.Instruction(inst) 19646 } else { 19647 c.adderror(err) 19648 } 19649} 19650 19651// VLDDQU: Load Unaligned Integer 128 Bits. 19652// 19653// Forms: 19654// 19655// VLDDQU m128 xmm 19656// VLDDQU m256 ymm 19657// Construct and append a VLDDQU instruction to the active function. 19658// Operates on the global context. 19659func VLDDQU(m, xy operand.Op) { ctx.VLDDQU(m, xy) } 19660 19661// VLDMXCSR: Load MXCSR Register. 19662// 19663// Forms: 19664// 19665// VLDMXCSR m32 19666// Construct and append a VLDMXCSR instruction to the active function. 19667func (c *Context) VLDMXCSR(m operand.Op) { 19668 if inst, err := x86.VLDMXCSR(m); err == nil { 19669 c.Instruction(inst) 19670 } else { 19671 c.adderror(err) 19672 } 19673} 19674 19675// VLDMXCSR: Load MXCSR Register. 19676// 19677// Forms: 19678// 19679// VLDMXCSR m32 19680// Construct and append a VLDMXCSR instruction to the active function. 19681// Operates on the global context. 19682func VLDMXCSR(m operand.Op) { ctx.VLDMXCSR(m) } 19683 19684// VMASKMOVDQU: Store Selected Bytes of Double Quadword. 19685// 19686// Forms: 19687// 19688// VMASKMOVDQU xmm xmm 19689// Construct and append a VMASKMOVDQU instruction to the active function. 19690func (c *Context) VMASKMOVDQU(x, x1 operand.Op) { 19691 if inst, err := x86.VMASKMOVDQU(x, x1); err == nil { 19692 c.Instruction(inst) 19693 } else { 19694 c.adderror(err) 19695 } 19696} 19697 19698// VMASKMOVDQU: Store Selected Bytes of Double Quadword. 19699// 19700// Forms: 19701// 19702// VMASKMOVDQU xmm xmm 19703// Construct and append a VMASKMOVDQU instruction to the active function. 19704// Operates on the global context. 19705func VMASKMOVDQU(x, x1 operand.Op) { ctx.VMASKMOVDQU(x, x1) } 19706 19707// VMASKMOVPD: Conditional Move Packed Double-Precision Floating-Point Values. 19708// 19709// Forms: 19710// 19711// VMASKMOVPD m128 xmm xmm 19712// VMASKMOVPD m256 ymm ymm 19713// VMASKMOVPD xmm xmm m128 19714// VMASKMOVPD ymm ymm m256 19715// Construct and append a VMASKMOVPD instruction to the active function. 19716func (c *Context) VMASKMOVPD(mxy, xy, mxy1 operand.Op) { 19717 if inst, err := x86.VMASKMOVPD(mxy, xy, mxy1); err == nil { 19718 c.Instruction(inst) 19719 } else { 19720 c.adderror(err) 19721 } 19722} 19723 19724// VMASKMOVPD: Conditional Move Packed Double-Precision Floating-Point Values. 19725// 19726// Forms: 19727// 19728// VMASKMOVPD m128 xmm xmm 19729// VMASKMOVPD m256 ymm ymm 19730// VMASKMOVPD xmm xmm m128 19731// VMASKMOVPD ymm ymm m256 19732// Construct and append a VMASKMOVPD instruction to the active function. 19733// Operates on the global context. 19734func VMASKMOVPD(mxy, xy, mxy1 operand.Op) { ctx.VMASKMOVPD(mxy, xy, mxy1) } 19735 19736// VMASKMOVPS: Conditional Move Packed Single-Precision Floating-Point Values. 19737// 19738// Forms: 19739// 19740// VMASKMOVPS m128 xmm xmm 19741// VMASKMOVPS m256 ymm ymm 19742// VMASKMOVPS xmm xmm m128 19743// VMASKMOVPS ymm ymm m256 19744// Construct and append a VMASKMOVPS instruction to the active function. 19745func (c *Context) VMASKMOVPS(mxy, xy, mxy1 operand.Op) { 19746 if inst, err := x86.VMASKMOVPS(mxy, xy, mxy1); err == nil { 19747 c.Instruction(inst) 19748 } else { 19749 c.adderror(err) 19750 } 19751} 19752 19753// VMASKMOVPS: Conditional Move Packed Single-Precision Floating-Point Values. 19754// 19755// Forms: 19756// 19757// VMASKMOVPS m128 xmm xmm 19758// VMASKMOVPS m256 ymm ymm 19759// VMASKMOVPS xmm xmm m128 19760// VMASKMOVPS ymm ymm m256 19761// Construct and append a VMASKMOVPS instruction to the active function. 19762// Operates on the global context. 19763func VMASKMOVPS(mxy, xy, mxy1 operand.Op) { ctx.VMASKMOVPS(mxy, xy, mxy1) } 19764 19765// VMAXPD: Return Maximum Packed Double-Precision Floating-Point Values. 19766// 19767// Forms: 19768// 19769// VMAXPD xmm xmm xmm 19770// VMAXPD m128 xmm xmm 19771// VMAXPD ymm ymm ymm 19772// VMAXPD m256 ymm ymm 19773// Construct and append a VMAXPD instruction to the active function. 19774func (c *Context) VMAXPD(mxy, xy, xy1 operand.Op) { 19775 if inst, err := x86.VMAXPD(mxy, xy, xy1); err == nil { 19776 c.Instruction(inst) 19777 } else { 19778 c.adderror(err) 19779 } 19780} 19781 19782// VMAXPD: Return Maximum Packed Double-Precision Floating-Point Values. 19783// 19784// Forms: 19785// 19786// VMAXPD xmm xmm xmm 19787// VMAXPD m128 xmm xmm 19788// VMAXPD ymm ymm ymm 19789// VMAXPD m256 ymm ymm 19790// Construct and append a VMAXPD instruction to the active function. 19791// Operates on the global context. 19792func VMAXPD(mxy, xy, xy1 operand.Op) { ctx.VMAXPD(mxy, xy, xy1) } 19793 19794// VMAXPS: Return Maximum Packed Single-Precision Floating-Point Values. 19795// 19796// Forms: 19797// 19798// VMAXPS xmm xmm xmm 19799// VMAXPS m128 xmm xmm 19800// VMAXPS ymm ymm ymm 19801// VMAXPS m256 ymm ymm 19802// Construct and append a VMAXPS instruction to the active function. 19803func (c *Context) VMAXPS(mxy, xy, xy1 operand.Op) { 19804 if inst, err := x86.VMAXPS(mxy, xy, xy1); err == nil { 19805 c.Instruction(inst) 19806 } else { 19807 c.adderror(err) 19808 } 19809} 19810 19811// VMAXPS: Return Maximum Packed Single-Precision Floating-Point Values. 19812// 19813// Forms: 19814// 19815// VMAXPS xmm xmm xmm 19816// VMAXPS m128 xmm xmm 19817// VMAXPS ymm ymm ymm 19818// VMAXPS m256 ymm ymm 19819// Construct and append a VMAXPS instruction to the active function. 19820// Operates on the global context. 19821func VMAXPS(mxy, xy, xy1 operand.Op) { ctx.VMAXPS(mxy, xy, xy1) } 19822 19823// VMAXSD: Return Maximum Scalar Double-Precision Floating-Point Value. 19824// 19825// Forms: 19826// 19827// VMAXSD xmm xmm xmm 19828// VMAXSD m64 xmm xmm 19829// Construct and append a VMAXSD instruction to the active function. 19830func (c *Context) VMAXSD(mx, x, x1 operand.Op) { 19831 if inst, err := x86.VMAXSD(mx, x, x1); err == nil { 19832 c.Instruction(inst) 19833 } else { 19834 c.adderror(err) 19835 } 19836} 19837 19838// VMAXSD: Return Maximum Scalar Double-Precision Floating-Point Value. 19839// 19840// Forms: 19841// 19842// VMAXSD xmm xmm xmm 19843// VMAXSD m64 xmm xmm 19844// Construct and append a VMAXSD instruction to the active function. 19845// Operates on the global context. 19846func VMAXSD(mx, x, x1 operand.Op) { ctx.VMAXSD(mx, x, x1) } 19847 19848// VMAXSS: Return Maximum Scalar Single-Precision Floating-Point Value. 19849// 19850// Forms: 19851// 19852// VMAXSS xmm xmm xmm 19853// VMAXSS m32 xmm xmm 19854// Construct and append a VMAXSS instruction to the active function. 19855func (c *Context) VMAXSS(mx, x, x1 operand.Op) { 19856 if inst, err := x86.VMAXSS(mx, x, x1); err == nil { 19857 c.Instruction(inst) 19858 } else { 19859 c.adderror(err) 19860 } 19861} 19862 19863// VMAXSS: Return Maximum Scalar Single-Precision Floating-Point Value. 19864// 19865// Forms: 19866// 19867// VMAXSS xmm xmm xmm 19868// VMAXSS m32 xmm xmm 19869// Construct and append a VMAXSS instruction to the active function. 19870// Operates on the global context. 19871func VMAXSS(mx, x, x1 operand.Op) { ctx.VMAXSS(mx, x, x1) } 19872 19873// VMINPD: Return Minimum Packed Double-Precision Floating-Point Values. 19874// 19875// Forms: 19876// 19877// VMINPD xmm xmm xmm 19878// VMINPD m128 xmm xmm 19879// VMINPD ymm ymm ymm 19880// VMINPD m256 ymm ymm 19881// Construct and append a VMINPD instruction to the active function. 19882func (c *Context) VMINPD(mxy, xy, xy1 operand.Op) { 19883 if inst, err := x86.VMINPD(mxy, xy, xy1); err == nil { 19884 c.Instruction(inst) 19885 } else { 19886 c.adderror(err) 19887 } 19888} 19889 19890// VMINPD: Return Minimum Packed Double-Precision Floating-Point Values. 19891// 19892// Forms: 19893// 19894// VMINPD xmm xmm xmm 19895// VMINPD m128 xmm xmm 19896// VMINPD ymm ymm ymm 19897// VMINPD m256 ymm ymm 19898// Construct and append a VMINPD instruction to the active function. 19899// Operates on the global context. 19900func VMINPD(mxy, xy, xy1 operand.Op) { ctx.VMINPD(mxy, xy, xy1) } 19901 19902// VMINPS: Return Minimum Packed Single-Precision Floating-Point Values. 19903// 19904// Forms: 19905// 19906// VMINPS xmm xmm xmm 19907// VMINPS m128 xmm xmm 19908// VMINPS ymm ymm ymm 19909// VMINPS m256 ymm ymm 19910// Construct and append a VMINPS instruction to the active function. 19911func (c *Context) VMINPS(mxy, xy, xy1 operand.Op) { 19912 if inst, err := x86.VMINPS(mxy, xy, xy1); err == nil { 19913 c.Instruction(inst) 19914 } else { 19915 c.adderror(err) 19916 } 19917} 19918 19919// VMINPS: Return Minimum Packed Single-Precision Floating-Point Values. 19920// 19921// Forms: 19922// 19923// VMINPS xmm xmm xmm 19924// VMINPS m128 xmm xmm 19925// VMINPS ymm ymm ymm 19926// VMINPS m256 ymm ymm 19927// Construct and append a VMINPS instruction to the active function. 19928// Operates on the global context. 19929func VMINPS(mxy, xy, xy1 operand.Op) { ctx.VMINPS(mxy, xy, xy1) } 19930 19931// VMINSD: Return Minimum Scalar Double-Precision Floating-Point Value. 19932// 19933// Forms: 19934// 19935// VMINSD xmm xmm xmm 19936// VMINSD m64 xmm xmm 19937// Construct and append a VMINSD instruction to the active function. 19938func (c *Context) VMINSD(mx, x, x1 operand.Op) { 19939 if inst, err := x86.VMINSD(mx, x, x1); err == nil { 19940 c.Instruction(inst) 19941 } else { 19942 c.adderror(err) 19943 } 19944} 19945 19946// VMINSD: Return Minimum Scalar Double-Precision Floating-Point Value. 19947// 19948// Forms: 19949// 19950// VMINSD xmm xmm xmm 19951// VMINSD m64 xmm xmm 19952// Construct and append a VMINSD instruction to the active function. 19953// Operates on the global context. 19954func VMINSD(mx, x, x1 operand.Op) { ctx.VMINSD(mx, x, x1) } 19955 19956// VMINSS: Return Minimum Scalar Single-Precision Floating-Point Value. 19957// 19958// Forms: 19959// 19960// VMINSS xmm xmm xmm 19961// VMINSS m32 xmm xmm 19962// Construct and append a VMINSS instruction to the active function. 19963func (c *Context) VMINSS(mx, x, x1 operand.Op) { 19964 if inst, err := x86.VMINSS(mx, x, x1); err == nil { 19965 c.Instruction(inst) 19966 } else { 19967 c.adderror(err) 19968 } 19969} 19970 19971// VMINSS: Return Minimum Scalar Single-Precision Floating-Point Value. 19972// 19973// Forms: 19974// 19975// VMINSS xmm xmm xmm 19976// VMINSS m32 xmm xmm 19977// Construct and append a VMINSS instruction to the active function. 19978// Operates on the global context. 19979func VMINSS(mx, x, x1 operand.Op) { ctx.VMINSS(mx, x, x1) } 19980 19981// VMOVAPD: Move Aligned Packed Double-Precision Floating-Point Values. 19982// 19983// Forms: 19984// 19985// VMOVAPD xmm xmm 19986// VMOVAPD m128 xmm 19987// VMOVAPD ymm ymm 19988// VMOVAPD m256 ymm 19989// VMOVAPD xmm m128 19990// VMOVAPD ymm m256 19991// Construct and append a VMOVAPD instruction to the active function. 19992func (c *Context) VMOVAPD(mxy, mxy1 operand.Op) { 19993 if inst, err := x86.VMOVAPD(mxy, mxy1); err == nil { 19994 c.Instruction(inst) 19995 } else { 19996 c.adderror(err) 19997 } 19998} 19999 20000// VMOVAPD: Move Aligned Packed Double-Precision Floating-Point Values. 20001// 20002// Forms: 20003// 20004// VMOVAPD xmm xmm 20005// VMOVAPD m128 xmm 20006// VMOVAPD ymm ymm 20007// VMOVAPD m256 ymm 20008// VMOVAPD xmm m128 20009// VMOVAPD ymm m256 20010// Construct and append a VMOVAPD instruction to the active function. 20011// Operates on the global context. 20012func VMOVAPD(mxy, mxy1 operand.Op) { ctx.VMOVAPD(mxy, mxy1) } 20013 20014// VMOVAPS: Move Aligned Packed Single-Precision Floating-Point Values. 20015// 20016// Forms: 20017// 20018// VMOVAPS xmm xmm 20019// VMOVAPS m128 xmm 20020// VMOVAPS ymm ymm 20021// VMOVAPS m256 ymm 20022// VMOVAPS xmm m128 20023// VMOVAPS ymm m256 20024// Construct and append a VMOVAPS instruction to the active function. 20025func (c *Context) VMOVAPS(mxy, mxy1 operand.Op) { 20026 if inst, err := x86.VMOVAPS(mxy, mxy1); err == nil { 20027 c.Instruction(inst) 20028 } else { 20029 c.adderror(err) 20030 } 20031} 20032 20033// VMOVAPS: Move Aligned Packed Single-Precision Floating-Point Values. 20034// 20035// Forms: 20036// 20037// VMOVAPS xmm xmm 20038// VMOVAPS m128 xmm 20039// VMOVAPS ymm ymm 20040// VMOVAPS m256 ymm 20041// VMOVAPS xmm m128 20042// VMOVAPS ymm m256 20043// Construct and append a VMOVAPS instruction to the active function. 20044// Operates on the global context. 20045func VMOVAPS(mxy, mxy1 operand.Op) { ctx.VMOVAPS(mxy, mxy1) } 20046 20047// VMOVD: Move Doubleword. 20048// 20049// Forms: 20050// 20051// VMOVD xmm r32 20052// VMOVD r32 xmm 20053// VMOVD m32 xmm 20054// VMOVD xmm m32 20055// Construct and append a VMOVD instruction to the active function. 20056func (c *Context) VMOVD(mrx, mrx1 operand.Op) { 20057 if inst, err := x86.VMOVD(mrx, mrx1); err == nil { 20058 c.Instruction(inst) 20059 } else { 20060 c.adderror(err) 20061 } 20062} 20063 20064// VMOVD: Move Doubleword. 20065// 20066// Forms: 20067// 20068// VMOVD xmm r32 20069// VMOVD r32 xmm 20070// VMOVD m32 xmm 20071// VMOVD xmm m32 20072// Construct and append a VMOVD instruction to the active function. 20073// Operates on the global context. 20074func VMOVD(mrx, mrx1 operand.Op) { ctx.VMOVD(mrx, mrx1) } 20075 20076// VMOVDDUP: Move One Double-FP and Duplicate. 20077// 20078// Forms: 20079// 20080// VMOVDDUP xmm xmm 20081// VMOVDDUP m64 xmm 20082// VMOVDDUP ymm ymm 20083// VMOVDDUP m256 ymm 20084// Construct and append a VMOVDDUP instruction to the active function. 20085func (c *Context) VMOVDDUP(mxy, xy operand.Op) { 20086 if inst, err := x86.VMOVDDUP(mxy, xy); err == nil { 20087 c.Instruction(inst) 20088 } else { 20089 c.adderror(err) 20090 } 20091} 20092 20093// VMOVDDUP: Move One Double-FP and Duplicate. 20094// 20095// Forms: 20096// 20097// VMOVDDUP xmm xmm 20098// VMOVDDUP m64 xmm 20099// VMOVDDUP ymm ymm 20100// VMOVDDUP m256 ymm 20101// Construct and append a VMOVDDUP instruction to the active function. 20102// Operates on the global context. 20103func VMOVDDUP(mxy, xy operand.Op) { ctx.VMOVDDUP(mxy, xy) } 20104 20105// VMOVDQA: Move Aligned Double Quadword. 20106// 20107// Forms: 20108// 20109// VMOVDQA xmm xmm 20110// VMOVDQA m128 xmm 20111// VMOVDQA ymm ymm 20112// VMOVDQA m256 ymm 20113// VMOVDQA xmm m128 20114// VMOVDQA ymm m256 20115// Construct and append a VMOVDQA instruction to the active function. 20116func (c *Context) VMOVDQA(mxy, mxy1 operand.Op) { 20117 if inst, err := x86.VMOVDQA(mxy, mxy1); err == nil { 20118 c.Instruction(inst) 20119 } else { 20120 c.adderror(err) 20121 } 20122} 20123 20124// VMOVDQA: Move Aligned Double Quadword. 20125// 20126// Forms: 20127// 20128// VMOVDQA xmm xmm 20129// VMOVDQA m128 xmm 20130// VMOVDQA ymm ymm 20131// VMOVDQA m256 ymm 20132// VMOVDQA xmm m128 20133// VMOVDQA ymm m256 20134// Construct and append a VMOVDQA instruction to the active function. 20135// Operates on the global context. 20136func VMOVDQA(mxy, mxy1 operand.Op) { ctx.VMOVDQA(mxy, mxy1) } 20137 20138// VMOVDQU: Move Unaligned Double Quadword. 20139// 20140// Forms: 20141// 20142// VMOVDQU xmm xmm 20143// VMOVDQU m128 xmm 20144// VMOVDQU ymm ymm 20145// VMOVDQU m256 ymm 20146// VMOVDQU xmm m128 20147// VMOVDQU ymm m256 20148// Construct and append a VMOVDQU instruction to the active function. 20149func (c *Context) VMOVDQU(mxy, mxy1 operand.Op) { 20150 if inst, err := x86.VMOVDQU(mxy, mxy1); err == nil { 20151 c.Instruction(inst) 20152 } else { 20153 c.adderror(err) 20154 } 20155} 20156 20157// VMOVDQU: Move Unaligned Double Quadword. 20158// 20159// Forms: 20160// 20161// VMOVDQU xmm xmm 20162// VMOVDQU m128 xmm 20163// VMOVDQU ymm ymm 20164// VMOVDQU m256 ymm 20165// VMOVDQU xmm m128 20166// VMOVDQU ymm m256 20167// Construct and append a VMOVDQU instruction to the active function. 20168// Operates on the global context. 20169func VMOVDQU(mxy, mxy1 operand.Op) { ctx.VMOVDQU(mxy, mxy1) } 20170 20171// VMOVHLPS: Move Packed Single-Precision Floating-Point Values High to Low. 20172// 20173// Forms: 20174// 20175// VMOVHLPS xmm xmm xmm 20176// Construct and append a VMOVHLPS instruction to the active function. 20177func (c *Context) VMOVHLPS(x, x1, x2 operand.Op) { 20178 if inst, err := x86.VMOVHLPS(x, x1, x2); err == nil { 20179 c.Instruction(inst) 20180 } else { 20181 c.adderror(err) 20182 } 20183} 20184 20185// VMOVHLPS: Move Packed Single-Precision Floating-Point Values High to Low. 20186// 20187// Forms: 20188// 20189// VMOVHLPS xmm xmm xmm 20190// Construct and append a VMOVHLPS instruction to the active function. 20191// Operates on the global context. 20192func VMOVHLPS(x, x1, x2 operand.Op) { ctx.VMOVHLPS(x, x1, x2) } 20193 20194// VMOVHPD: Move High Packed Double-Precision Floating-Point Value. 20195// 20196// Forms: 20197// 20198// VMOVHPD xmm m64 20199// VMOVHPD m64 xmm xmm 20200// Construct and append a VMOVHPD instruction to the active function. 20201func (c *Context) VMOVHPD(ops ...operand.Op) { 20202 if inst, err := x86.VMOVHPD(ops...); err == nil { 20203 c.Instruction(inst) 20204 } else { 20205 c.adderror(err) 20206 } 20207} 20208 20209// VMOVHPD: Move High Packed Double-Precision Floating-Point Value. 20210// 20211// Forms: 20212// 20213// VMOVHPD xmm m64 20214// VMOVHPD m64 xmm xmm 20215// Construct and append a VMOVHPD instruction to the active function. 20216// Operates on the global context. 20217func VMOVHPD(ops ...operand.Op) { ctx.VMOVHPD(ops...) } 20218 20219// VMOVHPS: Move High Packed Single-Precision Floating-Point Values. 20220// 20221// Forms: 20222// 20223// VMOVHPS xmm m64 20224// VMOVHPS m64 xmm xmm 20225// Construct and append a VMOVHPS instruction to the active function. 20226func (c *Context) VMOVHPS(ops ...operand.Op) { 20227 if inst, err := x86.VMOVHPS(ops...); err == nil { 20228 c.Instruction(inst) 20229 } else { 20230 c.adderror(err) 20231 } 20232} 20233 20234// VMOVHPS: Move High Packed Single-Precision Floating-Point Values. 20235// 20236// Forms: 20237// 20238// VMOVHPS xmm m64 20239// VMOVHPS m64 xmm xmm 20240// Construct and append a VMOVHPS instruction to the active function. 20241// Operates on the global context. 20242func VMOVHPS(ops ...operand.Op) { ctx.VMOVHPS(ops...) } 20243 20244// VMOVLHPS: Move Packed Single-Precision Floating-Point Values Low to High. 20245// 20246// Forms: 20247// 20248// VMOVLHPS xmm xmm xmm 20249// Construct and append a VMOVLHPS instruction to the active function. 20250func (c *Context) VMOVLHPS(x, x1, x2 operand.Op) { 20251 if inst, err := x86.VMOVLHPS(x, x1, x2); err == nil { 20252 c.Instruction(inst) 20253 } else { 20254 c.adderror(err) 20255 } 20256} 20257 20258// VMOVLHPS: Move Packed Single-Precision Floating-Point Values Low to High. 20259// 20260// Forms: 20261// 20262// VMOVLHPS xmm xmm xmm 20263// Construct and append a VMOVLHPS instruction to the active function. 20264// Operates on the global context. 20265func VMOVLHPS(x, x1, x2 operand.Op) { ctx.VMOVLHPS(x, x1, x2) } 20266 20267// VMOVLPD: Move Low Packed Double-Precision Floating-Point Value. 20268// 20269// Forms: 20270// 20271// VMOVLPD xmm m64 20272// VMOVLPD m64 xmm xmm 20273// Construct and append a VMOVLPD instruction to the active function. 20274func (c *Context) VMOVLPD(ops ...operand.Op) { 20275 if inst, err := x86.VMOVLPD(ops...); err == nil { 20276 c.Instruction(inst) 20277 } else { 20278 c.adderror(err) 20279 } 20280} 20281 20282// VMOVLPD: Move Low Packed Double-Precision Floating-Point Value. 20283// 20284// Forms: 20285// 20286// VMOVLPD xmm m64 20287// VMOVLPD m64 xmm xmm 20288// Construct and append a VMOVLPD instruction to the active function. 20289// Operates on the global context. 20290func VMOVLPD(ops ...operand.Op) { ctx.VMOVLPD(ops...) } 20291 20292// VMOVLPS: Move Low Packed Single-Precision Floating-Point Values. 20293// 20294// Forms: 20295// 20296// VMOVLPS xmm m64 20297// VMOVLPS m64 xmm xmm 20298// Construct and append a VMOVLPS instruction to the active function. 20299func (c *Context) VMOVLPS(ops ...operand.Op) { 20300 if inst, err := x86.VMOVLPS(ops...); err == nil { 20301 c.Instruction(inst) 20302 } else { 20303 c.adderror(err) 20304 } 20305} 20306 20307// VMOVLPS: Move Low Packed Single-Precision Floating-Point Values. 20308// 20309// Forms: 20310// 20311// VMOVLPS xmm m64 20312// VMOVLPS m64 xmm xmm 20313// Construct and append a VMOVLPS instruction to the active function. 20314// Operates on the global context. 20315func VMOVLPS(ops ...operand.Op) { ctx.VMOVLPS(ops...) } 20316 20317// VMOVMSKPD: Extract Packed Double-Precision Floating-Point Sign Mask. 20318// 20319// Forms: 20320// 20321// VMOVMSKPD xmm r32 20322// VMOVMSKPD ymm r32 20323// Construct and append a VMOVMSKPD instruction to the active function. 20324func (c *Context) VMOVMSKPD(xy, r operand.Op) { 20325 if inst, err := x86.VMOVMSKPD(xy, r); err == nil { 20326 c.Instruction(inst) 20327 } else { 20328 c.adderror(err) 20329 } 20330} 20331 20332// VMOVMSKPD: Extract Packed Double-Precision Floating-Point Sign Mask. 20333// 20334// Forms: 20335// 20336// VMOVMSKPD xmm r32 20337// VMOVMSKPD ymm r32 20338// Construct and append a VMOVMSKPD instruction to the active function. 20339// Operates on the global context. 20340func VMOVMSKPD(xy, r operand.Op) { ctx.VMOVMSKPD(xy, r) } 20341 20342// VMOVMSKPS: Extract Packed Single-Precision Floating-Point Sign Mask. 20343// 20344// Forms: 20345// 20346// VMOVMSKPS xmm r32 20347// VMOVMSKPS ymm r32 20348// Construct and append a VMOVMSKPS instruction to the active function. 20349func (c *Context) VMOVMSKPS(xy, r operand.Op) { 20350 if inst, err := x86.VMOVMSKPS(xy, r); err == nil { 20351 c.Instruction(inst) 20352 } else { 20353 c.adderror(err) 20354 } 20355} 20356 20357// VMOVMSKPS: Extract Packed Single-Precision Floating-Point Sign Mask. 20358// 20359// Forms: 20360// 20361// VMOVMSKPS xmm r32 20362// VMOVMSKPS ymm r32 20363// Construct and append a VMOVMSKPS instruction to the active function. 20364// Operates on the global context. 20365func VMOVMSKPS(xy, r operand.Op) { ctx.VMOVMSKPS(xy, r) } 20366 20367// VMOVNTDQ: Store Double Quadword Using Non-Temporal Hint. 20368// 20369// Forms: 20370// 20371// VMOVNTDQ xmm m128 20372// VMOVNTDQ ymm m256 20373// Construct and append a VMOVNTDQ instruction to the active function. 20374func (c *Context) VMOVNTDQ(xy, m operand.Op) { 20375 if inst, err := x86.VMOVNTDQ(xy, m); err == nil { 20376 c.Instruction(inst) 20377 } else { 20378 c.adderror(err) 20379 } 20380} 20381 20382// VMOVNTDQ: Store Double Quadword Using Non-Temporal Hint. 20383// 20384// Forms: 20385// 20386// VMOVNTDQ xmm m128 20387// VMOVNTDQ ymm m256 20388// Construct and append a VMOVNTDQ instruction to the active function. 20389// Operates on the global context. 20390func VMOVNTDQ(xy, m operand.Op) { ctx.VMOVNTDQ(xy, m) } 20391 20392// VMOVNTDQA: Load Double Quadword Non-Temporal Aligned Hint. 20393// 20394// Forms: 20395// 20396// VMOVNTDQA m128 xmm 20397// VMOVNTDQA m256 ymm 20398// Construct and append a VMOVNTDQA instruction to the active function. 20399func (c *Context) VMOVNTDQA(m, xy operand.Op) { 20400 if inst, err := x86.VMOVNTDQA(m, xy); err == nil { 20401 c.Instruction(inst) 20402 } else { 20403 c.adderror(err) 20404 } 20405} 20406 20407// VMOVNTDQA: Load Double Quadword Non-Temporal Aligned Hint. 20408// 20409// Forms: 20410// 20411// VMOVNTDQA m128 xmm 20412// VMOVNTDQA m256 ymm 20413// Construct and append a VMOVNTDQA instruction to the active function. 20414// Operates on the global context. 20415func VMOVNTDQA(m, xy operand.Op) { ctx.VMOVNTDQA(m, xy) } 20416 20417// VMOVNTPD: Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint. 20418// 20419// Forms: 20420// 20421// VMOVNTPD xmm m128 20422// VMOVNTPD ymm m256 20423// Construct and append a VMOVNTPD instruction to the active function. 20424func (c *Context) VMOVNTPD(xy, m operand.Op) { 20425 if inst, err := x86.VMOVNTPD(xy, m); err == nil { 20426 c.Instruction(inst) 20427 } else { 20428 c.adderror(err) 20429 } 20430} 20431 20432// VMOVNTPD: Store Packed Double-Precision Floating-Point Values Using Non-Temporal Hint. 20433// 20434// Forms: 20435// 20436// VMOVNTPD xmm m128 20437// VMOVNTPD ymm m256 20438// Construct and append a VMOVNTPD instruction to the active function. 20439// Operates on the global context. 20440func VMOVNTPD(xy, m operand.Op) { ctx.VMOVNTPD(xy, m) } 20441 20442// VMOVNTPS: Store Packed Single-Precision Floating-Point Values Using Non-Temporal Hint. 20443// 20444// Forms: 20445// 20446// VMOVNTPS xmm m128 20447// VMOVNTPS ymm m256 20448// Construct and append a VMOVNTPS instruction to the active function. 20449func (c *Context) VMOVNTPS(xy, m operand.Op) { 20450 if inst, err := x86.VMOVNTPS(xy, m); err == nil { 20451 c.Instruction(inst) 20452 } else { 20453 c.adderror(err) 20454 } 20455} 20456 20457// VMOVNTPS: Store Packed Single-Precision Floating-Point Values Using Non-Temporal Hint. 20458// 20459// Forms: 20460// 20461// VMOVNTPS xmm m128 20462// VMOVNTPS ymm m256 20463// Construct and append a VMOVNTPS instruction to the active function. 20464// Operates on the global context. 20465func VMOVNTPS(xy, m operand.Op) { ctx.VMOVNTPS(xy, m) } 20466 20467// VMOVQ: Move Quadword. 20468// 20469// Forms: 20470// 20471// VMOVQ xmm r64 20472// VMOVQ r64 xmm 20473// VMOVQ xmm xmm 20474// VMOVQ m64 xmm 20475// VMOVQ xmm m64 20476// Construct and append a VMOVQ instruction to the active function. 20477func (c *Context) VMOVQ(mrx, mrx1 operand.Op) { 20478 if inst, err := x86.VMOVQ(mrx, mrx1); err == nil { 20479 c.Instruction(inst) 20480 } else { 20481 c.adderror(err) 20482 } 20483} 20484 20485// VMOVQ: Move Quadword. 20486// 20487// Forms: 20488// 20489// VMOVQ xmm r64 20490// VMOVQ r64 xmm 20491// VMOVQ xmm xmm 20492// VMOVQ m64 xmm 20493// VMOVQ xmm m64 20494// Construct and append a VMOVQ instruction to the active function. 20495// Operates on the global context. 20496func VMOVQ(mrx, mrx1 operand.Op) { ctx.VMOVQ(mrx, mrx1) } 20497 20498// VMOVSD: Move Scalar Double-Precision Floating-Point Value. 20499// 20500// Forms: 20501// 20502// VMOVSD m64 xmm 20503// VMOVSD xmm m64 20504// VMOVSD xmm xmm xmm 20505// Construct and append a VMOVSD instruction to the active function. 20506func (c *Context) VMOVSD(ops ...operand.Op) { 20507 if inst, err := x86.VMOVSD(ops...); err == nil { 20508 c.Instruction(inst) 20509 } else { 20510 c.adderror(err) 20511 } 20512} 20513 20514// VMOVSD: Move Scalar Double-Precision Floating-Point Value. 20515// 20516// Forms: 20517// 20518// VMOVSD m64 xmm 20519// VMOVSD xmm m64 20520// VMOVSD xmm xmm xmm 20521// Construct and append a VMOVSD instruction to the active function. 20522// Operates on the global context. 20523func VMOVSD(ops ...operand.Op) { ctx.VMOVSD(ops...) } 20524 20525// VMOVSHDUP: Move Packed Single-FP High and Duplicate. 20526// 20527// Forms: 20528// 20529// VMOVSHDUP xmm xmm 20530// VMOVSHDUP m128 xmm 20531// VMOVSHDUP ymm ymm 20532// VMOVSHDUP m256 ymm 20533// Construct and append a VMOVSHDUP instruction to the active function. 20534func (c *Context) VMOVSHDUP(mxy, xy operand.Op) { 20535 if inst, err := x86.VMOVSHDUP(mxy, xy); err == nil { 20536 c.Instruction(inst) 20537 } else { 20538 c.adderror(err) 20539 } 20540} 20541 20542// VMOVSHDUP: Move Packed Single-FP High and Duplicate. 20543// 20544// Forms: 20545// 20546// VMOVSHDUP xmm xmm 20547// VMOVSHDUP m128 xmm 20548// VMOVSHDUP ymm ymm 20549// VMOVSHDUP m256 ymm 20550// Construct and append a VMOVSHDUP instruction to the active function. 20551// Operates on the global context. 20552func VMOVSHDUP(mxy, xy operand.Op) { ctx.VMOVSHDUP(mxy, xy) } 20553 20554// VMOVSLDUP: Move Packed Single-FP Low and Duplicate. 20555// 20556// Forms: 20557// 20558// VMOVSLDUP xmm xmm 20559// VMOVSLDUP m128 xmm 20560// VMOVSLDUP ymm ymm 20561// VMOVSLDUP m256 ymm 20562// Construct and append a VMOVSLDUP instruction to the active function. 20563func (c *Context) VMOVSLDUP(mxy, xy operand.Op) { 20564 if inst, err := x86.VMOVSLDUP(mxy, xy); err == nil { 20565 c.Instruction(inst) 20566 } else { 20567 c.adderror(err) 20568 } 20569} 20570 20571// VMOVSLDUP: Move Packed Single-FP Low and Duplicate. 20572// 20573// Forms: 20574// 20575// VMOVSLDUP xmm xmm 20576// VMOVSLDUP m128 xmm 20577// VMOVSLDUP ymm ymm 20578// VMOVSLDUP m256 ymm 20579// Construct and append a VMOVSLDUP instruction to the active function. 20580// Operates on the global context. 20581func VMOVSLDUP(mxy, xy operand.Op) { ctx.VMOVSLDUP(mxy, xy) } 20582 20583// VMOVSS: Move Scalar Single-Precision Floating-Point Values. 20584// 20585// Forms: 20586// 20587// VMOVSS m32 xmm 20588// VMOVSS xmm m32 20589// VMOVSS xmm xmm xmm 20590// Construct and append a VMOVSS instruction to the active function. 20591func (c *Context) VMOVSS(ops ...operand.Op) { 20592 if inst, err := x86.VMOVSS(ops...); err == nil { 20593 c.Instruction(inst) 20594 } else { 20595 c.adderror(err) 20596 } 20597} 20598 20599// VMOVSS: Move Scalar Single-Precision Floating-Point Values. 20600// 20601// Forms: 20602// 20603// VMOVSS m32 xmm 20604// VMOVSS xmm m32 20605// VMOVSS xmm xmm xmm 20606// Construct and append a VMOVSS instruction to the active function. 20607// Operates on the global context. 20608func VMOVSS(ops ...operand.Op) { ctx.VMOVSS(ops...) } 20609 20610// VMOVUPD: Move Unaligned Packed Double-Precision Floating-Point Values. 20611// 20612// Forms: 20613// 20614// VMOVUPD xmm xmm 20615// VMOVUPD m128 xmm 20616// VMOVUPD ymm ymm 20617// VMOVUPD m256 ymm 20618// VMOVUPD xmm m128 20619// VMOVUPD ymm m256 20620// Construct and append a VMOVUPD instruction to the active function. 20621func (c *Context) VMOVUPD(mxy, mxy1 operand.Op) { 20622 if inst, err := x86.VMOVUPD(mxy, mxy1); err == nil { 20623 c.Instruction(inst) 20624 } else { 20625 c.adderror(err) 20626 } 20627} 20628 20629// VMOVUPD: Move Unaligned Packed Double-Precision Floating-Point Values. 20630// 20631// Forms: 20632// 20633// VMOVUPD xmm xmm 20634// VMOVUPD m128 xmm 20635// VMOVUPD ymm ymm 20636// VMOVUPD m256 ymm 20637// VMOVUPD xmm m128 20638// VMOVUPD ymm m256 20639// Construct and append a VMOVUPD instruction to the active function. 20640// Operates on the global context. 20641func VMOVUPD(mxy, mxy1 operand.Op) { ctx.VMOVUPD(mxy, mxy1) } 20642 20643// VMOVUPS: Move Unaligned Packed Single-Precision Floating-Point Values. 20644// 20645// Forms: 20646// 20647// VMOVUPS xmm xmm 20648// VMOVUPS m128 xmm 20649// VMOVUPS ymm ymm 20650// VMOVUPS m256 ymm 20651// VMOVUPS xmm m128 20652// VMOVUPS ymm m256 20653// Construct and append a VMOVUPS instruction to the active function. 20654func (c *Context) VMOVUPS(mxy, mxy1 operand.Op) { 20655 if inst, err := x86.VMOVUPS(mxy, mxy1); err == nil { 20656 c.Instruction(inst) 20657 } else { 20658 c.adderror(err) 20659 } 20660} 20661 20662// VMOVUPS: Move Unaligned Packed Single-Precision Floating-Point Values. 20663// 20664// Forms: 20665// 20666// VMOVUPS xmm xmm 20667// VMOVUPS m128 xmm 20668// VMOVUPS ymm ymm 20669// VMOVUPS m256 ymm 20670// VMOVUPS xmm m128 20671// VMOVUPS ymm m256 20672// Construct and append a VMOVUPS instruction to the active function. 20673// Operates on the global context. 20674func VMOVUPS(mxy, mxy1 operand.Op) { ctx.VMOVUPS(mxy, mxy1) } 20675 20676// VMPSADBW: Compute Multiple Packed Sums of Absolute Difference. 20677// 20678// Forms: 20679// 20680// VMPSADBW imm8 xmm xmm xmm 20681// VMPSADBW imm8 m128 xmm xmm 20682// VMPSADBW imm8 ymm ymm ymm 20683// VMPSADBW imm8 m256 ymm ymm 20684// Construct and append a VMPSADBW instruction to the active function. 20685func (c *Context) VMPSADBW(i, mxy, xy, xy1 operand.Op) { 20686 if inst, err := x86.VMPSADBW(i, mxy, xy, xy1); err == nil { 20687 c.Instruction(inst) 20688 } else { 20689 c.adderror(err) 20690 } 20691} 20692 20693// VMPSADBW: Compute Multiple Packed Sums of Absolute Difference. 20694// 20695// Forms: 20696// 20697// VMPSADBW imm8 xmm xmm xmm 20698// VMPSADBW imm8 m128 xmm xmm 20699// VMPSADBW imm8 ymm ymm ymm 20700// VMPSADBW imm8 m256 ymm ymm 20701// Construct and append a VMPSADBW instruction to the active function. 20702// Operates on the global context. 20703func VMPSADBW(i, mxy, xy, xy1 operand.Op) { ctx.VMPSADBW(i, mxy, xy, xy1) } 20704 20705// VMULPD: Multiply Packed Double-Precision Floating-Point Values. 20706// 20707// Forms: 20708// 20709// VMULPD xmm xmm xmm 20710// VMULPD m128 xmm xmm 20711// VMULPD ymm ymm ymm 20712// VMULPD m256 ymm ymm 20713// Construct and append a VMULPD instruction to the active function. 20714func (c *Context) VMULPD(mxy, xy, xy1 operand.Op) { 20715 if inst, err := x86.VMULPD(mxy, xy, xy1); err == nil { 20716 c.Instruction(inst) 20717 } else { 20718 c.adderror(err) 20719 } 20720} 20721 20722// VMULPD: Multiply Packed Double-Precision Floating-Point Values. 20723// 20724// Forms: 20725// 20726// VMULPD xmm xmm xmm 20727// VMULPD m128 xmm xmm 20728// VMULPD ymm ymm ymm 20729// VMULPD m256 ymm ymm 20730// Construct and append a VMULPD instruction to the active function. 20731// Operates on the global context. 20732func VMULPD(mxy, xy, xy1 operand.Op) { ctx.VMULPD(mxy, xy, xy1) } 20733 20734// VMULPS: Multiply Packed Single-Precision Floating-Point Values. 20735// 20736// Forms: 20737// 20738// VMULPS xmm xmm xmm 20739// VMULPS m128 xmm xmm 20740// VMULPS ymm ymm ymm 20741// VMULPS m256 ymm ymm 20742// Construct and append a VMULPS instruction to the active function. 20743func (c *Context) VMULPS(mxy, xy, xy1 operand.Op) { 20744 if inst, err := x86.VMULPS(mxy, xy, xy1); err == nil { 20745 c.Instruction(inst) 20746 } else { 20747 c.adderror(err) 20748 } 20749} 20750 20751// VMULPS: Multiply Packed Single-Precision Floating-Point Values. 20752// 20753// Forms: 20754// 20755// VMULPS xmm xmm xmm 20756// VMULPS m128 xmm xmm 20757// VMULPS ymm ymm ymm 20758// VMULPS m256 ymm ymm 20759// Construct and append a VMULPS instruction to the active function. 20760// Operates on the global context. 20761func VMULPS(mxy, xy, xy1 operand.Op) { ctx.VMULPS(mxy, xy, xy1) } 20762 20763// VMULSD: Multiply Scalar Double-Precision Floating-Point Values. 20764// 20765// Forms: 20766// 20767// VMULSD xmm xmm xmm 20768// VMULSD m64 xmm xmm 20769// Construct and append a VMULSD instruction to the active function. 20770func (c *Context) VMULSD(mx, x, x1 operand.Op) { 20771 if inst, err := x86.VMULSD(mx, x, x1); err == nil { 20772 c.Instruction(inst) 20773 } else { 20774 c.adderror(err) 20775 } 20776} 20777 20778// VMULSD: Multiply Scalar Double-Precision Floating-Point Values. 20779// 20780// Forms: 20781// 20782// VMULSD xmm xmm xmm 20783// VMULSD m64 xmm xmm 20784// Construct and append a VMULSD instruction to the active function. 20785// Operates on the global context. 20786func VMULSD(mx, x, x1 operand.Op) { ctx.VMULSD(mx, x, x1) } 20787 20788// VMULSS: Multiply Scalar Single-Precision Floating-Point Values. 20789// 20790// Forms: 20791// 20792// VMULSS xmm xmm xmm 20793// VMULSS m32 xmm xmm 20794// Construct and append a VMULSS instruction to the active function. 20795func (c *Context) VMULSS(mx, x, x1 operand.Op) { 20796 if inst, err := x86.VMULSS(mx, x, x1); err == nil { 20797 c.Instruction(inst) 20798 } else { 20799 c.adderror(err) 20800 } 20801} 20802 20803// VMULSS: Multiply Scalar Single-Precision Floating-Point Values. 20804// 20805// Forms: 20806// 20807// VMULSS xmm xmm xmm 20808// VMULSS m32 xmm xmm 20809// Construct and append a VMULSS instruction to the active function. 20810// Operates on the global context. 20811func VMULSS(mx, x, x1 operand.Op) { ctx.VMULSS(mx, x, x1) } 20812 20813// VORPD: Bitwise Logical OR of Double-Precision Floating-Point Values. 20814// 20815// Forms: 20816// 20817// VORPD xmm xmm xmm 20818// VORPD m128 xmm xmm 20819// VORPD ymm ymm ymm 20820// VORPD m256 ymm ymm 20821// Construct and append a VORPD instruction to the active function. 20822func (c *Context) VORPD(mxy, xy, xy1 operand.Op) { 20823 if inst, err := x86.VORPD(mxy, xy, xy1); err == nil { 20824 c.Instruction(inst) 20825 } else { 20826 c.adderror(err) 20827 } 20828} 20829 20830// VORPD: Bitwise Logical OR of Double-Precision Floating-Point Values. 20831// 20832// Forms: 20833// 20834// VORPD xmm xmm xmm 20835// VORPD m128 xmm xmm 20836// VORPD ymm ymm ymm 20837// VORPD m256 ymm ymm 20838// Construct and append a VORPD instruction to the active function. 20839// Operates on the global context. 20840func VORPD(mxy, xy, xy1 operand.Op) { ctx.VORPD(mxy, xy, xy1) } 20841 20842// VORPS: Bitwise Logical OR of Single-Precision Floating-Point Values. 20843// 20844// Forms: 20845// 20846// VORPS xmm xmm xmm 20847// VORPS m128 xmm xmm 20848// VORPS ymm ymm ymm 20849// VORPS m256 ymm ymm 20850// Construct and append a VORPS instruction to the active function. 20851func (c *Context) VORPS(mxy, xy, xy1 operand.Op) { 20852 if inst, err := x86.VORPS(mxy, xy, xy1); err == nil { 20853 c.Instruction(inst) 20854 } else { 20855 c.adderror(err) 20856 } 20857} 20858 20859// VORPS: Bitwise Logical OR of Single-Precision Floating-Point Values. 20860// 20861// Forms: 20862// 20863// VORPS xmm xmm xmm 20864// VORPS m128 xmm xmm 20865// VORPS ymm ymm ymm 20866// VORPS m256 ymm ymm 20867// Construct and append a VORPS instruction to the active function. 20868// Operates on the global context. 20869func VORPS(mxy, xy, xy1 operand.Op) { ctx.VORPS(mxy, xy, xy1) } 20870 20871// VPABSB: Packed Absolute Value of Byte Integers. 20872// 20873// Forms: 20874// 20875// VPABSB xmm xmm 20876// VPABSB m128 xmm 20877// VPABSB ymm ymm 20878// VPABSB m256 ymm 20879// Construct and append a VPABSB instruction to the active function. 20880func (c *Context) VPABSB(mxy, xy operand.Op) { 20881 if inst, err := x86.VPABSB(mxy, xy); err == nil { 20882 c.Instruction(inst) 20883 } else { 20884 c.adderror(err) 20885 } 20886} 20887 20888// VPABSB: Packed Absolute Value of Byte Integers. 20889// 20890// Forms: 20891// 20892// VPABSB xmm xmm 20893// VPABSB m128 xmm 20894// VPABSB ymm ymm 20895// VPABSB m256 ymm 20896// Construct and append a VPABSB instruction to the active function. 20897// Operates on the global context. 20898func VPABSB(mxy, xy operand.Op) { ctx.VPABSB(mxy, xy) } 20899 20900// VPABSD: Packed Absolute Value of Doubleword Integers. 20901// 20902// Forms: 20903// 20904// VPABSD xmm xmm 20905// VPABSD m128 xmm 20906// VPABSD ymm ymm 20907// VPABSD m256 ymm 20908// Construct and append a VPABSD instruction to the active function. 20909func (c *Context) VPABSD(mxy, xy operand.Op) { 20910 if inst, err := x86.VPABSD(mxy, xy); err == nil { 20911 c.Instruction(inst) 20912 } else { 20913 c.adderror(err) 20914 } 20915} 20916 20917// VPABSD: Packed Absolute Value of Doubleword Integers. 20918// 20919// Forms: 20920// 20921// VPABSD xmm xmm 20922// VPABSD m128 xmm 20923// VPABSD ymm ymm 20924// VPABSD m256 ymm 20925// Construct and append a VPABSD instruction to the active function. 20926// Operates on the global context. 20927func VPABSD(mxy, xy operand.Op) { ctx.VPABSD(mxy, xy) } 20928 20929// VPABSW: Packed Absolute Value of Word Integers. 20930// 20931// Forms: 20932// 20933// VPABSW xmm xmm 20934// VPABSW m128 xmm 20935// VPABSW ymm ymm 20936// VPABSW m256 ymm 20937// Construct and append a VPABSW instruction to the active function. 20938func (c *Context) VPABSW(mxy, xy operand.Op) { 20939 if inst, err := x86.VPABSW(mxy, xy); err == nil { 20940 c.Instruction(inst) 20941 } else { 20942 c.adderror(err) 20943 } 20944} 20945 20946// VPABSW: Packed Absolute Value of Word Integers. 20947// 20948// Forms: 20949// 20950// VPABSW xmm xmm 20951// VPABSW m128 xmm 20952// VPABSW ymm ymm 20953// VPABSW m256 ymm 20954// Construct and append a VPABSW instruction to the active function. 20955// Operates on the global context. 20956func VPABSW(mxy, xy operand.Op) { ctx.VPABSW(mxy, xy) } 20957 20958// VPACKSSDW: Pack Doublewords into Words with Signed Saturation. 20959// 20960// Forms: 20961// 20962// VPACKSSDW xmm xmm xmm 20963// VPACKSSDW m128 xmm xmm 20964// VPACKSSDW ymm ymm ymm 20965// VPACKSSDW m256 ymm ymm 20966// Construct and append a VPACKSSDW instruction to the active function. 20967func (c *Context) VPACKSSDW(mxy, xy, xy1 operand.Op) { 20968 if inst, err := x86.VPACKSSDW(mxy, xy, xy1); err == nil { 20969 c.Instruction(inst) 20970 } else { 20971 c.adderror(err) 20972 } 20973} 20974 20975// VPACKSSDW: Pack Doublewords into Words with Signed Saturation. 20976// 20977// Forms: 20978// 20979// VPACKSSDW xmm xmm xmm 20980// VPACKSSDW m128 xmm xmm 20981// VPACKSSDW ymm ymm ymm 20982// VPACKSSDW m256 ymm ymm 20983// Construct and append a VPACKSSDW instruction to the active function. 20984// Operates on the global context. 20985func VPACKSSDW(mxy, xy, xy1 operand.Op) { ctx.VPACKSSDW(mxy, xy, xy1) } 20986 20987// VPACKSSWB: Pack Words into Bytes with Signed Saturation. 20988// 20989// Forms: 20990// 20991// VPACKSSWB xmm xmm xmm 20992// VPACKSSWB m128 xmm xmm 20993// VPACKSSWB ymm ymm ymm 20994// VPACKSSWB m256 ymm ymm 20995// Construct and append a VPACKSSWB instruction to the active function. 20996func (c *Context) VPACKSSWB(mxy, xy, xy1 operand.Op) { 20997 if inst, err := x86.VPACKSSWB(mxy, xy, xy1); err == nil { 20998 c.Instruction(inst) 20999 } else { 21000 c.adderror(err) 21001 } 21002} 21003 21004// VPACKSSWB: Pack Words into Bytes with Signed Saturation. 21005// 21006// Forms: 21007// 21008// VPACKSSWB xmm xmm xmm 21009// VPACKSSWB m128 xmm xmm 21010// VPACKSSWB ymm ymm ymm 21011// VPACKSSWB m256 ymm ymm 21012// Construct and append a VPACKSSWB instruction to the active function. 21013// Operates on the global context. 21014func VPACKSSWB(mxy, xy, xy1 operand.Op) { ctx.VPACKSSWB(mxy, xy, xy1) } 21015 21016// VPACKUSDW: Pack Doublewords into Words with Unsigned Saturation. 21017// 21018// Forms: 21019// 21020// VPACKUSDW xmm xmm xmm 21021// VPACKUSDW m128 xmm xmm 21022// VPACKUSDW ymm ymm ymm 21023// VPACKUSDW m256 ymm ymm 21024// Construct and append a VPACKUSDW instruction to the active function. 21025func (c *Context) VPACKUSDW(mxy, xy, xy1 operand.Op) { 21026 if inst, err := x86.VPACKUSDW(mxy, xy, xy1); err == nil { 21027 c.Instruction(inst) 21028 } else { 21029 c.adderror(err) 21030 } 21031} 21032 21033// VPACKUSDW: Pack Doublewords into Words with Unsigned Saturation. 21034// 21035// Forms: 21036// 21037// VPACKUSDW xmm xmm xmm 21038// VPACKUSDW m128 xmm xmm 21039// VPACKUSDW ymm ymm ymm 21040// VPACKUSDW m256 ymm ymm 21041// Construct and append a VPACKUSDW instruction to the active function. 21042// Operates on the global context. 21043func VPACKUSDW(mxy, xy, xy1 operand.Op) { ctx.VPACKUSDW(mxy, xy, xy1) } 21044 21045// VPACKUSWB: Pack Words into Bytes with Unsigned Saturation. 21046// 21047// Forms: 21048// 21049// VPACKUSWB xmm xmm xmm 21050// VPACKUSWB m128 xmm xmm 21051// VPACKUSWB ymm ymm ymm 21052// VPACKUSWB m256 ymm ymm 21053// Construct and append a VPACKUSWB instruction to the active function. 21054func (c *Context) VPACKUSWB(mxy, xy, xy1 operand.Op) { 21055 if inst, err := x86.VPACKUSWB(mxy, xy, xy1); err == nil { 21056 c.Instruction(inst) 21057 } else { 21058 c.adderror(err) 21059 } 21060} 21061 21062// VPACKUSWB: Pack Words into Bytes with Unsigned Saturation. 21063// 21064// Forms: 21065// 21066// VPACKUSWB xmm xmm xmm 21067// VPACKUSWB m128 xmm xmm 21068// VPACKUSWB ymm ymm ymm 21069// VPACKUSWB m256 ymm ymm 21070// Construct and append a VPACKUSWB instruction to the active function. 21071// Operates on the global context. 21072func VPACKUSWB(mxy, xy, xy1 operand.Op) { ctx.VPACKUSWB(mxy, xy, xy1) } 21073 21074// VPADDB: Add Packed Byte Integers. 21075// 21076// Forms: 21077// 21078// VPADDB xmm xmm xmm 21079// VPADDB m128 xmm xmm 21080// VPADDB ymm ymm ymm 21081// VPADDB m256 ymm ymm 21082// Construct and append a VPADDB instruction to the active function. 21083func (c *Context) VPADDB(mxy, xy, xy1 operand.Op) { 21084 if inst, err := x86.VPADDB(mxy, xy, xy1); err == nil { 21085 c.Instruction(inst) 21086 } else { 21087 c.adderror(err) 21088 } 21089} 21090 21091// VPADDB: Add Packed Byte Integers. 21092// 21093// Forms: 21094// 21095// VPADDB xmm xmm xmm 21096// VPADDB m128 xmm xmm 21097// VPADDB ymm ymm ymm 21098// VPADDB m256 ymm ymm 21099// Construct and append a VPADDB instruction to the active function. 21100// Operates on the global context. 21101func VPADDB(mxy, xy, xy1 operand.Op) { ctx.VPADDB(mxy, xy, xy1) } 21102 21103// VPADDD: Add Packed Doubleword Integers. 21104// 21105// Forms: 21106// 21107// VPADDD xmm xmm xmm 21108// VPADDD m128 xmm xmm 21109// VPADDD ymm ymm ymm 21110// VPADDD m256 ymm ymm 21111// Construct and append a VPADDD instruction to the active function. 21112func (c *Context) VPADDD(mxy, xy, xy1 operand.Op) { 21113 if inst, err := x86.VPADDD(mxy, xy, xy1); err == nil { 21114 c.Instruction(inst) 21115 } else { 21116 c.adderror(err) 21117 } 21118} 21119 21120// VPADDD: Add Packed Doubleword Integers. 21121// 21122// Forms: 21123// 21124// VPADDD xmm xmm xmm 21125// VPADDD m128 xmm xmm 21126// VPADDD ymm ymm ymm 21127// VPADDD m256 ymm ymm 21128// Construct and append a VPADDD instruction to the active function. 21129// Operates on the global context. 21130func VPADDD(mxy, xy, xy1 operand.Op) { ctx.VPADDD(mxy, xy, xy1) } 21131 21132// VPADDQ: Add Packed Quadword Integers. 21133// 21134// Forms: 21135// 21136// VPADDQ xmm xmm xmm 21137// VPADDQ m128 xmm xmm 21138// VPADDQ ymm ymm ymm 21139// VPADDQ m256 ymm ymm 21140// Construct and append a VPADDQ instruction to the active function. 21141func (c *Context) VPADDQ(mxy, xy, xy1 operand.Op) { 21142 if inst, err := x86.VPADDQ(mxy, xy, xy1); err == nil { 21143 c.Instruction(inst) 21144 } else { 21145 c.adderror(err) 21146 } 21147} 21148 21149// VPADDQ: Add Packed Quadword Integers. 21150// 21151// Forms: 21152// 21153// VPADDQ xmm xmm xmm 21154// VPADDQ m128 xmm xmm 21155// VPADDQ ymm ymm ymm 21156// VPADDQ m256 ymm ymm 21157// Construct and append a VPADDQ instruction to the active function. 21158// Operates on the global context. 21159func VPADDQ(mxy, xy, xy1 operand.Op) { ctx.VPADDQ(mxy, xy, xy1) } 21160 21161// VPADDSB: Add Packed Signed Byte Integers with Signed Saturation. 21162// 21163// Forms: 21164// 21165// VPADDSB xmm xmm xmm 21166// VPADDSB m128 xmm xmm 21167// VPADDSB ymm ymm ymm 21168// VPADDSB m256 ymm ymm 21169// Construct and append a VPADDSB instruction to the active function. 21170func (c *Context) VPADDSB(mxy, xy, xy1 operand.Op) { 21171 if inst, err := x86.VPADDSB(mxy, xy, xy1); err == nil { 21172 c.Instruction(inst) 21173 } else { 21174 c.adderror(err) 21175 } 21176} 21177 21178// VPADDSB: Add Packed Signed Byte Integers with Signed Saturation. 21179// 21180// Forms: 21181// 21182// VPADDSB xmm xmm xmm 21183// VPADDSB m128 xmm xmm 21184// VPADDSB ymm ymm ymm 21185// VPADDSB m256 ymm ymm 21186// Construct and append a VPADDSB instruction to the active function. 21187// Operates on the global context. 21188func VPADDSB(mxy, xy, xy1 operand.Op) { ctx.VPADDSB(mxy, xy, xy1) } 21189 21190// VPADDSW: Add Packed Signed Word Integers with Signed Saturation. 21191// 21192// Forms: 21193// 21194// VPADDSW xmm xmm xmm 21195// VPADDSW m128 xmm xmm 21196// VPADDSW ymm ymm ymm 21197// VPADDSW m256 ymm ymm 21198// Construct and append a VPADDSW instruction to the active function. 21199func (c *Context) VPADDSW(mxy, xy, xy1 operand.Op) { 21200 if inst, err := x86.VPADDSW(mxy, xy, xy1); err == nil { 21201 c.Instruction(inst) 21202 } else { 21203 c.adderror(err) 21204 } 21205} 21206 21207// VPADDSW: Add Packed Signed Word Integers with Signed Saturation. 21208// 21209// Forms: 21210// 21211// VPADDSW xmm xmm xmm 21212// VPADDSW m128 xmm xmm 21213// VPADDSW ymm ymm ymm 21214// VPADDSW m256 ymm ymm 21215// Construct and append a VPADDSW instruction to the active function. 21216// Operates on the global context. 21217func VPADDSW(mxy, xy, xy1 operand.Op) { ctx.VPADDSW(mxy, xy, xy1) } 21218 21219// VPADDUSB: Add Packed Unsigned Byte Integers with Unsigned Saturation. 21220// 21221// Forms: 21222// 21223// VPADDUSB xmm xmm xmm 21224// VPADDUSB m128 xmm xmm 21225// VPADDUSB ymm ymm ymm 21226// VPADDUSB m256 ymm ymm 21227// Construct and append a VPADDUSB instruction to the active function. 21228func (c *Context) VPADDUSB(mxy, xy, xy1 operand.Op) { 21229 if inst, err := x86.VPADDUSB(mxy, xy, xy1); err == nil { 21230 c.Instruction(inst) 21231 } else { 21232 c.adderror(err) 21233 } 21234} 21235 21236// VPADDUSB: Add Packed Unsigned Byte Integers with Unsigned Saturation. 21237// 21238// Forms: 21239// 21240// VPADDUSB xmm xmm xmm 21241// VPADDUSB m128 xmm xmm 21242// VPADDUSB ymm ymm ymm 21243// VPADDUSB m256 ymm ymm 21244// Construct and append a VPADDUSB instruction to the active function. 21245// Operates on the global context. 21246func VPADDUSB(mxy, xy, xy1 operand.Op) { ctx.VPADDUSB(mxy, xy, xy1) } 21247 21248// VPADDUSW: Add Packed Unsigned Word Integers with Unsigned Saturation. 21249// 21250// Forms: 21251// 21252// VPADDUSW xmm xmm xmm 21253// VPADDUSW m128 xmm xmm 21254// VPADDUSW ymm ymm ymm 21255// VPADDUSW m256 ymm ymm 21256// Construct and append a VPADDUSW instruction to the active function. 21257func (c *Context) VPADDUSW(mxy, xy, xy1 operand.Op) { 21258 if inst, err := x86.VPADDUSW(mxy, xy, xy1); err == nil { 21259 c.Instruction(inst) 21260 } else { 21261 c.adderror(err) 21262 } 21263} 21264 21265// VPADDUSW: Add Packed Unsigned Word Integers with Unsigned Saturation. 21266// 21267// Forms: 21268// 21269// VPADDUSW xmm xmm xmm 21270// VPADDUSW m128 xmm xmm 21271// VPADDUSW ymm ymm ymm 21272// VPADDUSW m256 ymm ymm 21273// Construct and append a VPADDUSW instruction to the active function. 21274// Operates on the global context. 21275func VPADDUSW(mxy, xy, xy1 operand.Op) { ctx.VPADDUSW(mxy, xy, xy1) } 21276 21277// VPADDW: Add Packed Word Integers. 21278// 21279// Forms: 21280// 21281// VPADDW xmm xmm xmm 21282// VPADDW m128 xmm xmm 21283// VPADDW ymm ymm ymm 21284// VPADDW m256 ymm ymm 21285// Construct and append a VPADDW instruction to the active function. 21286func (c *Context) VPADDW(mxy, xy, xy1 operand.Op) { 21287 if inst, err := x86.VPADDW(mxy, xy, xy1); err == nil { 21288 c.Instruction(inst) 21289 } else { 21290 c.adderror(err) 21291 } 21292} 21293 21294// VPADDW: Add Packed Word Integers. 21295// 21296// Forms: 21297// 21298// VPADDW xmm xmm xmm 21299// VPADDW m128 xmm xmm 21300// VPADDW ymm ymm ymm 21301// VPADDW m256 ymm ymm 21302// Construct and append a VPADDW instruction to the active function. 21303// Operates on the global context. 21304func VPADDW(mxy, xy, xy1 operand.Op) { ctx.VPADDW(mxy, xy, xy1) } 21305 21306// VPALIGNR: Packed Align Right. 21307// 21308// Forms: 21309// 21310// VPALIGNR imm8 xmm xmm xmm 21311// VPALIGNR imm8 m128 xmm xmm 21312// VPALIGNR imm8 ymm ymm ymm 21313// VPALIGNR imm8 m256 ymm ymm 21314// Construct and append a VPALIGNR instruction to the active function. 21315func (c *Context) VPALIGNR(i, mxy, xy, xy1 operand.Op) { 21316 if inst, err := x86.VPALIGNR(i, mxy, xy, xy1); err == nil { 21317 c.Instruction(inst) 21318 } else { 21319 c.adderror(err) 21320 } 21321} 21322 21323// VPALIGNR: Packed Align Right. 21324// 21325// Forms: 21326// 21327// VPALIGNR imm8 xmm xmm xmm 21328// VPALIGNR imm8 m128 xmm xmm 21329// VPALIGNR imm8 ymm ymm ymm 21330// VPALIGNR imm8 m256 ymm ymm 21331// Construct and append a VPALIGNR instruction to the active function. 21332// Operates on the global context. 21333func VPALIGNR(i, mxy, xy, xy1 operand.Op) { ctx.VPALIGNR(i, mxy, xy, xy1) } 21334 21335// VPAND: Packed Bitwise Logical AND. 21336// 21337// Forms: 21338// 21339// VPAND xmm xmm xmm 21340// VPAND m128 xmm xmm 21341// VPAND ymm ymm ymm 21342// VPAND m256 ymm ymm 21343// Construct and append a VPAND instruction to the active function. 21344func (c *Context) VPAND(mxy, xy, xy1 operand.Op) { 21345 if inst, err := x86.VPAND(mxy, xy, xy1); err == nil { 21346 c.Instruction(inst) 21347 } else { 21348 c.adderror(err) 21349 } 21350} 21351 21352// VPAND: Packed Bitwise Logical AND. 21353// 21354// Forms: 21355// 21356// VPAND xmm xmm xmm 21357// VPAND m128 xmm xmm 21358// VPAND ymm ymm ymm 21359// VPAND m256 ymm ymm 21360// Construct and append a VPAND instruction to the active function. 21361// Operates on the global context. 21362func VPAND(mxy, xy, xy1 operand.Op) { ctx.VPAND(mxy, xy, xy1) } 21363 21364// VPANDN: Packed Bitwise Logical AND NOT. 21365// 21366// Forms: 21367// 21368// VPANDN xmm xmm xmm 21369// VPANDN m128 xmm xmm 21370// VPANDN ymm ymm ymm 21371// VPANDN m256 ymm ymm 21372// Construct and append a VPANDN instruction to the active function. 21373func (c *Context) VPANDN(mxy, xy, xy1 operand.Op) { 21374 if inst, err := x86.VPANDN(mxy, xy, xy1); err == nil { 21375 c.Instruction(inst) 21376 } else { 21377 c.adderror(err) 21378 } 21379} 21380 21381// VPANDN: Packed Bitwise Logical AND NOT. 21382// 21383// Forms: 21384// 21385// VPANDN xmm xmm xmm 21386// VPANDN m128 xmm xmm 21387// VPANDN ymm ymm ymm 21388// VPANDN m256 ymm ymm 21389// Construct and append a VPANDN instruction to the active function. 21390// Operates on the global context. 21391func VPANDN(mxy, xy, xy1 operand.Op) { ctx.VPANDN(mxy, xy, xy1) } 21392 21393// VPAVGB: Average Packed Byte Integers. 21394// 21395// Forms: 21396// 21397// VPAVGB xmm xmm xmm 21398// VPAVGB m128 xmm xmm 21399// VPAVGB ymm ymm ymm 21400// VPAVGB m256 ymm ymm 21401// Construct and append a VPAVGB instruction to the active function. 21402func (c *Context) VPAVGB(mxy, xy, xy1 operand.Op) { 21403 if inst, err := x86.VPAVGB(mxy, xy, xy1); err == nil { 21404 c.Instruction(inst) 21405 } else { 21406 c.adderror(err) 21407 } 21408} 21409 21410// VPAVGB: Average Packed Byte Integers. 21411// 21412// Forms: 21413// 21414// VPAVGB xmm xmm xmm 21415// VPAVGB m128 xmm xmm 21416// VPAVGB ymm ymm ymm 21417// VPAVGB m256 ymm ymm 21418// Construct and append a VPAVGB instruction to the active function. 21419// Operates on the global context. 21420func VPAVGB(mxy, xy, xy1 operand.Op) { ctx.VPAVGB(mxy, xy, xy1) } 21421 21422// VPAVGW: Average Packed Word Integers. 21423// 21424// Forms: 21425// 21426// VPAVGW xmm xmm xmm 21427// VPAVGW m128 xmm xmm 21428// VPAVGW ymm ymm ymm 21429// VPAVGW m256 ymm ymm 21430// Construct and append a VPAVGW instruction to the active function. 21431func (c *Context) VPAVGW(mxy, xy, xy1 operand.Op) { 21432 if inst, err := x86.VPAVGW(mxy, xy, xy1); err == nil { 21433 c.Instruction(inst) 21434 } else { 21435 c.adderror(err) 21436 } 21437} 21438 21439// VPAVGW: Average Packed Word Integers. 21440// 21441// Forms: 21442// 21443// VPAVGW xmm xmm xmm 21444// VPAVGW m128 xmm xmm 21445// VPAVGW ymm ymm ymm 21446// VPAVGW m256 ymm ymm 21447// Construct and append a VPAVGW instruction to the active function. 21448// Operates on the global context. 21449func VPAVGW(mxy, xy, xy1 operand.Op) { ctx.VPAVGW(mxy, xy, xy1) } 21450 21451// VPBLENDD: Blend Packed Doublewords. 21452// 21453// Forms: 21454// 21455// VPBLENDD imm8 xmm xmm xmm 21456// VPBLENDD imm8 m128 xmm xmm 21457// VPBLENDD imm8 ymm ymm ymm 21458// VPBLENDD imm8 m256 ymm ymm 21459// Construct and append a VPBLENDD instruction to the active function. 21460func (c *Context) VPBLENDD(i, mxy, xy, xy1 operand.Op) { 21461 if inst, err := x86.VPBLENDD(i, mxy, xy, xy1); err == nil { 21462 c.Instruction(inst) 21463 } else { 21464 c.adderror(err) 21465 } 21466} 21467 21468// VPBLENDD: Blend Packed Doublewords. 21469// 21470// Forms: 21471// 21472// VPBLENDD imm8 xmm xmm xmm 21473// VPBLENDD imm8 m128 xmm xmm 21474// VPBLENDD imm8 ymm ymm ymm 21475// VPBLENDD imm8 m256 ymm ymm 21476// Construct and append a VPBLENDD instruction to the active function. 21477// Operates on the global context. 21478func VPBLENDD(i, mxy, xy, xy1 operand.Op) { ctx.VPBLENDD(i, mxy, xy, xy1) } 21479 21480// VPBLENDVB: Variable Blend Packed Bytes. 21481// 21482// Forms: 21483// 21484// VPBLENDVB xmm xmm xmm xmm 21485// VPBLENDVB xmm m128 xmm xmm 21486// VPBLENDVB ymm ymm ymm ymm 21487// VPBLENDVB ymm m256 ymm ymm 21488// Construct and append a VPBLENDVB instruction to the active function. 21489func (c *Context) VPBLENDVB(xy, mxy, xy1, xy2 operand.Op) { 21490 if inst, err := x86.VPBLENDVB(xy, mxy, xy1, xy2); err == nil { 21491 c.Instruction(inst) 21492 } else { 21493 c.adderror(err) 21494 } 21495} 21496 21497// VPBLENDVB: Variable Blend Packed Bytes. 21498// 21499// Forms: 21500// 21501// VPBLENDVB xmm xmm xmm xmm 21502// VPBLENDVB xmm m128 xmm xmm 21503// VPBLENDVB ymm ymm ymm ymm 21504// VPBLENDVB ymm m256 ymm ymm 21505// Construct and append a VPBLENDVB instruction to the active function. 21506// Operates on the global context. 21507func VPBLENDVB(xy, mxy, xy1, xy2 operand.Op) { ctx.VPBLENDVB(xy, mxy, xy1, xy2) } 21508 21509// VPBLENDW: Blend Packed Words. 21510// 21511// Forms: 21512// 21513// VPBLENDW imm8 xmm xmm xmm 21514// VPBLENDW imm8 m128 xmm xmm 21515// VPBLENDW imm8 ymm ymm ymm 21516// VPBLENDW imm8 m256 ymm ymm 21517// Construct and append a VPBLENDW instruction to the active function. 21518func (c *Context) VPBLENDW(i, mxy, xy, xy1 operand.Op) { 21519 if inst, err := x86.VPBLENDW(i, mxy, xy, xy1); err == nil { 21520 c.Instruction(inst) 21521 } else { 21522 c.adderror(err) 21523 } 21524} 21525 21526// VPBLENDW: Blend Packed Words. 21527// 21528// Forms: 21529// 21530// VPBLENDW imm8 xmm xmm xmm 21531// VPBLENDW imm8 m128 xmm xmm 21532// VPBLENDW imm8 ymm ymm ymm 21533// VPBLENDW imm8 m256 ymm ymm 21534// Construct and append a VPBLENDW instruction to the active function. 21535// Operates on the global context. 21536func VPBLENDW(i, mxy, xy, xy1 operand.Op) { ctx.VPBLENDW(i, mxy, xy, xy1) } 21537 21538// VPBROADCASTB: Broadcast Byte Integer. 21539// 21540// Forms: 21541// 21542// VPBROADCASTB xmm xmm 21543// VPBROADCASTB m8 xmm 21544// VPBROADCASTB xmm ymm 21545// VPBROADCASTB m8 ymm 21546// Construct and append a VPBROADCASTB instruction to the active function. 21547func (c *Context) VPBROADCASTB(mx, xy operand.Op) { 21548 if inst, err := x86.VPBROADCASTB(mx, xy); err == nil { 21549 c.Instruction(inst) 21550 } else { 21551 c.adderror(err) 21552 } 21553} 21554 21555// VPBROADCASTB: Broadcast Byte Integer. 21556// 21557// Forms: 21558// 21559// VPBROADCASTB xmm xmm 21560// VPBROADCASTB m8 xmm 21561// VPBROADCASTB xmm ymm 21562// VPBROADCASTB m8 ymm 21563// Construct and append a VPBROADCASTB instruction to the active function. 21564// Operates on the global context. 21565func VPBROADCASTB(mx, xy operand.Op) { ctx.VPBROADCASTB(mx, xy) } 21566 21567// VPBROADCASTD: Broadcast Doubleword Integer. 21568// 21569// Forms: 21570// 21571// VPBROADCASTD xmm xmm 21572// VPBROADCASTD m32 xmm 21573// VPBROADCASTD xmm ymm 21574// VPBROADCASTD m32 ymm 21575// Construct and append a VPBROADCASTD instruction to the active function. 21576func (c *Context) VPBROADCASTD(mx, xy operand.Op) { 21577 if inst, err := x86.VPBROADCASTD(mx, xy); err == nil { 21578 c.Instruction(inst) 21579 } else { 21580 c.adderror(err) 21581 } 21582} 21583 21584// VPBROADCASTD: Broadcast Doubleword Integer. 21585// 21586// Forms: 21587// 21588// VPBROADCASTD xmm xmm 21589// VPBROADCASTD m32 xmm 21590// VPBROADCASTD xmm ymm 21591// VPBROADCASTD m32 ymm 21592// Construct and append a VPBROADCASTD instruction to the active function. 21593// Operates on the global context. 21594func VPBROADCASTD(mx, xy operand.Op) { ctx.VPBROADCASTD(mx, xy) } 21595 21596// VPBROADCASTQ: Broadcast Quadword Integer. 21597// 21598// Forms: 21599// 21600// VPBROADCASTQ xmm xmm 21601// VPBROADCASTQ m64 xmm 21602// VPBROADCASTQ xmm ymm 21603// VPBROADCASTQ m64 ymm 21604// Construct and append a VPBROADCASTQ instruction to the active function. 21605func (c *Context) VPBROADCASTQ(mx, xy operand.Op) { 21606 if inst, err := x86.VPBROADCASTQ(mx, xy); err == nil { 21607 c.Instruction(inst) 21608 } else { 21609 c.adderror(err) 21610 } 21611} 21612 21613// VPBROADCASTQ: Broadcast Quadword Integer. 21614// 21615// Forms: 21616// 21617// VPBROADCASTQ xmm xmm 21618// VPBROADCASTQ m64 xmm 21619// VPBROADCASTQ xmm ymm 21620// VPBROADCASTQ m64 ymm 21621// Construct and append a VPBROADCASTQ instruction to the active function. 21622// Operates on the global context. 21623func VPBROADCASTQ(mx, xy operand.Op) { ctx.VPBROADCASTQ(mx, xy) } 21624 21625// VPBROADCASTW: Broadcast Word Integer. 21626// 21627// Forms: 21628// 21629// VPBROADCASTW xmm xmm 21630// VPBROADCASTW m16 xmm 21631// VPBROADCASTW xmm ymm 21632// VPBROADCASTW m16 ymm 21633// Construct and append a VPBROADCASTW instruction to the active function. 21634func (c *Context) VPBROADCASTW(mx, xy operand.Op) { 21635 if inst, err := x86.VPBROADCASTW(mx, xy); err == nil { 21636 c.Instruction(inst) 21637 } else { 21638 c.adderror(err) 21639 } 21640} 21641 21642// VPBROADCASTW: Broadcast Word Integer. 21643// 21644// Forms: 21645// 21646// VPBROADCASTW xmm xmm 21647// VPBROADCASTW m16 xmm 21648// VPBROADCASTW xmm ymm 21649// VPBROADCASTW m16 ymm 21650// Construct and append a VPBROADCASTW instruction to the active function. 21651// Operates on the global context. 21652func VPBROADCASTW(mx, xy operand.Op) { ctx.VPBROADCASTW(mx, xy) } 21653 21654// VPCLMULQDQ: Carry-Less Quadword Multiplication. 21655// 21656// Forms: 21657// 21658// VPCLMULQDQ imm8 xmm xmm xmm 21659// VPCLMULQDQ imm8 m128 xmm xmm 21660// Construct and append a VPCLMULQDQ instruction to the active function. 21661func (c *Context) VPCLMULQDQ(i, mx, x, x1 operand.Op) { 21662 if inst, err := x86.VPCLMULQDQ(i, mx, x, x1); err == nil { 21663 c.Instruction(inst) 21664 } else { 21665 c.adderror(err) 21666 } 21667} 21668 21669// VPCLMULQDQ: Carry-Less Quadword Multiplication. 21670// 21671// Forms: 21672// 21673// VPCLMULQDQ imm8 xmm xmm xmm 21674// VPCLMULQDQ imm8 m128 xmm xmm 21675// Construct and append a VPCLMULQDQ instruction to the active function. 21676// Operates on the global context. 21677func VPCLMULQDQ(i, mx, x, x1 operand.Op) { ctx.VPCLMULQDQ(i, mx, x, x1) } 21678 21679// VPCMPEQB: Compare Packed Byte Data for Equality. 21680// 21681// Forms: 21682// 21683// VPCMPEQB xmm xmm xmm 21684// VPCMPEQB m128 xmm xmm 21685// VPCMPEQB ymm ymm ymm 21686// VPCMPEQB m256 ymm ymm 21687// Construct and append a VPCMPEQB instruction to the active function. 21688func (c *Context) VPCMPEQB(mxy, xy, xy1 operand.Op) { 21689 if inst, err := x86.VPCMPEQB(mxy, xy, xy1); err == nil { 21690 c.Instruction(inst) 21691 } else { 21692 c.adderror(err) 21693 } 21694} 21695 21696// VPCMPEQB: Compare Packed Byte Data for Equality. 21697// 21698// Forms: 21699// 21700// VPCMPEQB xmm xmm xmm 21701// VPCMPEQB m128 xmm xmm 21702// VPCMPEQB ymm ymm ymm 21703// VPCMPEQB m256 ymm ymm 21704// Construct and append a VPCMPEQB instruction to the active function. 21705// Operates on the global context. 21706func VPCMPEQB(mxy, xy, xy1 operand.Op) { ctx.VPCMPEQB(mxy, xy, xy1) } 21707 21708// VPCMPEQD: Compare Packed Doubleword Data for Equality. 21709// 21710// Forms: 21711// 21712// VPCMPEQD xmm xmm xmm 21713// VPCMPEQD m128 xmm xmm 21714// VPCMPEQD ymm ymm ymm 21715// VPCMPEQD m256 ymm ymm 21716// Construct and append a VPCMPEQD instruction to the active function. 21717func (c *Context) VPCMPEQD(mxy, xy, xy1 operand.Op) { 21718 if inst, err := x86.VPCMPEQD(mxy, xy, xy1); err == nil { 21719 c.Instruction(inst) 21720 } else { 21721 c.adderror(err) 21722 } 21723} 21724 21725// VPCMPEQD: Compare Packed Doubleword Data for Equality. 21726// 21727// Forms: 21728// 21729// VPCMPEQD xmm xmm xmm 21730// VPCMPEQD m128 xmm xmm 21731// VPCMPEQD ymm ymm ymm 21732// VPCMPEQD m256 ymm ymm 21733// Construct and append a VPCMPEQD instruction to the active function. 21734// Operates on the global context. 21735func VPCMPEQD(mxy, xy, xy1 operand.Op) { ctx.VPCMPEQD(mxy, xy, xy1) } 21736 21737// VPCMPEQQ: Compare Packed Quadword Data for Equality. 21738// 21739// Forms: 21740// 21741// VPCMPEQQ xmm xmm xmm 21742// VPCMPEQQ m128 xmm xmm 21743// VPCMPEQQ ymm ymm ymm 21744// VPCMPEQQ m256 ymm ymm 21745// Construct and append a VPCMPEQQ instruction to the active function. 21746func (c *Context) VPCMPEQQ(mxy, xy, xy1 operand.Op) { 21747 if inst, err := x86.VPCMPEQQ(mxy, xy, xy1); err == nil { 21748 c.Instruction(inst) 21749 } else { 21750 c.adderror(err) 21751 } 21752} 21753 21754// VPCMPEQQ: Compare Packed Quadword Data for Equality. 21755// 21756// Forms: 21757// 21758// VPCMPEQQ xmm xmm xmm 21759// VPCMPEQQ m128 xmm xmm 21760// VPCMPEQQ ymm ymm ymm 21761// VPCMPEQQ m256 ymm ymm 21762// Construct and append a VPCMPEQQ instruction to the active function. 21763// Operates on the global context. 21764func VPCMPEQQ(mxy, xy, xy1 operand.Op) { ctx.VPCMPEQQ(mxy, xy, xy1) } 21765 21766// VPCMPEQW: Compare Packed Word Data for Equality. 21767// 21768// Forms: 21769// 21770// VPCMPEQW xmm xmm xmm 21771// VPCMPEQW m128 xmm xmm 21772// VPCMPEQW ymm ymm ymm 21773// VPCMPEQW m256 ymm ymm 21774// Construct and append a VPCMPEQW instruction to the active function. 21775func (c *Context) VPCMPEQW(mxy, xy, xy1 operand.Op) { 21776 if inst, err := x86.VPCMPEQW(mxy, xy, xy1); err == nil { 21777 c.Instruction(inst) 21778 } else { 21779 c.adderror(err) 21780 } 21781} 21782 21783// VPCMPEQW: Compare Packed Word Data for Equality. 21784// 21785// Forms: 21786// 21787// VPCMPEQW xmm xmm xmm 21788// VPCMPEQW m128 xmm xmm 21789// VPCMPEQW ymm ymm ymm 21790// VPCMPEQW m256 ymm ymm 21791// Construct and append a VPCMPEQW instruction to the active function. 21792// Operates on the global context. 21793func VPCMPEQW(mxy, xy, xy1 operand.Op) { ctx.VPCMPEQW(mxy, xy, xy1) } 21794 21795// VPCMPESTRI: Packed Compare Explicit Length Strings, Return Index. 21796// 21797// Forms: 21798// 21799// VPCMPESTRI imm8 xmm xmm 21800// VPCMPESTRI imm8 m128 xmm 21801// Construct and append a VPCMPESTRI instruction to the active function. 21802func (c *Context) VPCMPESTRI(i, mx, x operand.Op) { 21803 if inst, err := x86.VPCMPESTRI(i, mx, x); err == nil { 21804 c.Instruction(inst) 21805 } else { 21806 c.adderror(err) 21807 } 21808} 21809 21810// VPCMPESTRI: Packed Compare Explicit Length Strings, Return Index. 21811// 21812// Forms: 21813// 21814// VPCMPESTRI imm8 xmm xmm 21815// VPCMPESTRI imm8 m128 xmm 21816// Construct and append a VPCMPESTRI instruction to the active function. 21817// Operates on the global context. 21818func VPCMPESTRI(i, mx, x operand.Op) { ctx.VPCMPESTRI(i, mx, x) } 21819 21820// VPCMPESTRM: Packed Compare Explicit Length Strings, Return Mask. 21821// 21822// Forms: 21823// 21824// VPCMPESTRM imm8 xmm xmm 21825// VPCMPESTRM imm8 m128 xmm 21826// Construct and append a VPCMPESTRM instruction to the active function. 21827func (c *Context) VPCMPESTRM(i, mx, x operand.Op) { 21828 if inst, err := x86.VPCMPESTRM(i, mx, x); err == nil { 21829 c.Instruction(inst) 21830 } else { 21831 c.adderror(err) 21832 } 21833} 21834 21835// VPCMPESTRM: Packed Compare Explicit Length Strings, Return Mask. 21836// 21837// Forms: 21838// 21839// VPCMPESTRM imm8 xmm xmm 21840// VPCMPESTRM imm8 m128 xmm 21841// Construct and append a VPCMPESTRM instruction to the active function. 21842// Operates on the global context. 21843func VPCMPESTRM(i, mx, x operand.Op) { ctx.VPCMPESTRM(i, mx, x) } 21844 21845// VPCMPGTB: Compare Packed Signed Byte Integers for Greater Than. 21846// 21847// Forms: 21848// 21849// VPCMPGTB xmm xmm xmm 21850// VPCMPGTB m128 xmm xmm 21851// VPCMPGTB ymm ymm ymm 21852// VPCMPGTB m256 ymm ymm 21853// Construct and append a VPCMPGTB instruction to the active function. 21854func (c *Context) VPCMPGTB(mxy, xy, xy1 operand.Op) { 21855 if inst, err := x86.VPCMPGTB(mxy, xy, xy1); err == nil { 21856 c.Instruction(inst) 21857 } else { 21858 c.adderror(err) 21859 } 21860} 21861 21862// VPCMPGTB: Compare Packed Signed Byte Integers for Greater Than. 21863// 21864// Forms: 21865// 21866// VPCMPGTB xmm xmm xmm 21867// VPCMPGTB m128 xmm xmm 21868// VPCMPGTB ymm ymm ymm 21869// VPCMPGTB m256 ymm ymm 21870// Construct and append a VPCMPGTB instruction to the active function. 21871// Operates on the global context. 21872func VPCMPGTB(mxy, xy, xy1 operand.Op) { ctx.VPCMPGTB(mxy, xy, xy1) } 21873 21874// VPCMPGTD: Compare Packed Signed Doubleword Integers for Greater Than. 21875// 21876// Forms: 21877// 21878// VPCMPGTD xmm xmm xmm 21879// VPCMPGTD m128 xmm xmm 21880// VPCMPGTD ymm ymm ymm 21881// VPCMPGTD m256 ymm ymm 21882// Construct and append a VPCMPGTD instruction to the active function. 21883func (c *Context) VPCMPGTD(mxy, xy, xy1 operand.Op) { 21884 if inst, err := x86.VPCMPGTD(mxy, xy, xy1); err == nil { 21885 c.Instruction(inst) 21886 } else { 21887 c.adderror(err) 21888 } 21889} 21890 21891// VPCMPGTD: Compare Packed Signed Doubleword Integers for Greater Than. 21892// 21893// Forms: 21894// 21895// VPCMPGTD xmm xmm xmm 21896// VPCMPGTD m128 xmm xmm 21897// VPCMPGTD ymm ymm ymm 21898// VPCMPGTD m256 ymm ymm 21899// Construct and append a VPCMPGTD instruction to the active function. 21900// Operates on the global context. 21901func VPCMPGTD(mxy, xy, xy1 operand.Op) { ctx.VPCMPGTD(mxy, xy, xy1) } 21902 21903// VPCMPGTQ: Compare Packed Data for Greater Than. 21904// 21905// Forms: 21906// 21907// VPCMPGTQ xmm xmm xmm 21908// VPCMPGTQ m128 xmm xmm 21909// VPCMPGTQ ymm ymm ymm 21910// VPCMPGTQ m256 ymm ymm 21911// Construct and append a VPCMPGTQ instruction to the active function. 21912func (c *Context) VPCMPGTQ(mxy, xy, xy1 operand.Op) { 21913 if inst, err := x86.VPCMPGTQ(mxy, xy, xy1); err == nil { 21914 c.Instruction(inst) 21915 } else { 21916 c.adderror(err) 21917 } 21918} 21919 21920// VPCMPGTQ: Compare Packed Data for Greater Than. 21921// 21922// Forms: 21923// 21924// VPCMPGTQ xmm xmm xmm 21925// VPCMPGTQ m128 xmm xmm 21926// VPCMPGTQ ymm ymm ymm 21927// VPCMPGTQ m256 ymm ymm 21928// Construct and append a VPCMPGTQ instruction to the active function. 21929// Operates on the global context. 21930func VPCMPGTQ(mxy, xy, xy1 operand.Op) { ctx.VPCMPGTQ(mxy, xy, xy1) } 21931 21932// VPCMPGTW: Compare Packed Signed Word Integers for Greater Than. 21933// 21934// Forms: 21935// 21936// VPCMPGTW xmm xmm xmm 21937// VPCMPGTW m128 xmm xmm 21938// VPCMPGTW ymm ymm ymm 21939// VPCMPGTW m256 ymm ymm 21940// Construct and append a VPCMPGTW instruction to the active function. 21941func (c *Context) VPCMPGTW(mxy, xy, xy1 operand.Op) { 21942 if inst, err := x86.VPCMPGTW(mxy, xy, xy1); err == nil { 21943 c.Instruction(inst) 21944 } else { 21945 c.adderror(err) 21946 } 21947} 21948 21949// VPCMPGTW: Compare Packed Signed Word Integers for Greater Than. 21950// 21951// Forms: 21952// 21953// VPCMPGTW xmm xmm xmm 21954// VPCMPGTW m128 xmm xmm 21955// VPCMPGTW ymm ymm ymm 21956// VPCMPGTW m256 ymm ymm 21957// Construct and append a VPCMPGTW instruction to the active function. 21958// Operates on the global context. 21959func VPCMPGTW(mxy, xy, xy1 operand.Op) { ctx.VPCMPGTW(mxy, xy, xy1) } 21960 21961// VPCMPISTRI: Packed Compare Implicit Length Strings, Return Index. 21962// 21963// Forms: 21964// 21965// VPCMPISTRI imm8 xmm xmm 21966// VPCMPISTRI imm8 m128 xmm 21967// Construct and append a VPCMPISTRI instruction to the active function. 21968func (c *Context) VPCMPISTRI(i, mx, x operand.Op) { 21969 if inst, err := x86.VPCMPISTRI(i, mx, x); err == nil { 21970 c.Instruction(inst) 21971 } else { 21972 c.adderror(err) 21973 } 21974} 21975 21976// VPCMPISTRI: Packed Compare Implicit Length Strings, Return Index. 21977// 21978// Forms: 21979// 21980// VPCMPISTRI imm8 xmm xmm 21981// VPCMPISTRI imm8 m128 xmm 21982// Construct and append a VPCMPISTRI instruction to the active function. 21983// Operates on the global context. 21984func VPCMPISTRI(i, mx, x operand.Op) { ctx.VPCMPISTRI(i, mx, x) } 21985 21986// VPCMPISTRM: Packed Compare Implicit Length Strings, Return Mask. 21987// 21988// Forms: 21989// 21990// VPCMPISTRM imm8 xmm xmm 21991// VPCMPISTRM imm8 m128 xmm 21992// Construct and append a VPCMPISTRM instruction to the active function. 21993func (c *Context) VPCMPISTRM(i, mx, x operand.Op) { 21994 if inst, err := x86.VPCMPISTRM(i, mx, x); err == nil { 21995 c.Instruction(inst) 21996 } else { 21997 c.adderror(err) 21998 } 21999} 22000 22001// VPCMPISTRM: Packed Compare Implicit Length Strings, Return Mask. 22002// 22003// Forms: 22004// 22005// VPCMPISTRM imm8 xmm xmm 22006// VPCMPISTRM imm8 m128 xmm 22007// Construct and append a VPCMPISTRM instruction to the active function. 22008// Operates on the global context. 22009func VPCMPISTRM(i, mx, x operand.Op) { ctx.VPCMPISTRM(i, mx, x) } 22010 22011// VPERM2F128: Permute Floating-Point Values. 22012// 22013// Forms: 22014// 22015// VPERM2F128 imm8 ymm ymm ymm 22016// VPERM2F128 imm8 m256 ymm ymm 22017// Construct and append a VPERM2F128 instruction to the active function. 22018func (c *Context) VPERM2F128(i, my, y, y1 operand.Op) { 22019 if inst, err := x86.VPERM2F128(i, my, y, y1); err == nil { 22020 c.Instruction(inst) 22021 } else { 22022 c.adderror(err) 22023 } 22024} 22025 22026// VPERM2F128: Permute Floating-Point Values. 22027// 22028// Forms: 22029// 22030// VPERM2F128 imm8 ymm ymm ymm 22031// VPERM2F128 imm8 m256 ymm ymm 22032// Construct and append a VPERM2F128 instruction to the active function. 22033// Operates on the global context. 22034func VPERM2F128(i, my, y, y1 operand.Op) { ctx.VPERM2F128(i, my, y, y1) } 22035 22036// VPERM2I128: Permute 128-Bit Integer Values. 22037// 22038// Forms: 22039// 22040// VPERM2I128 imm8 ymm ymm ymm 22041// VPERM2I128 imm8 m256 ymm ymm 22042// Construct and append a VPERM2I128 instruction to the active function. 22043func (c *Context) VPERM2I128(i, my, y, y1 operand.Op) { 22044 if inst, err := x86.VPERM2I128(i, my, y, y1); err == nil { 22045 c.Instruction(inst) 22046 } else { 22047 c.adderror(err) 22048 } 22049} 22050 22051// VPERM2I128: Permute 128-Bit Integer Values. 22052// 22053// Forms: 22054// 22055// VPERM2I128 imm8 ymm ymm ymm 22056// VPERM2I128 imm8 m256 ymm ymm 22057// Construct and append a VPERM2I128 instruction to the active function. 22058// Operates on the global context. 22059func VPERM2I128(i, my, y, y1 operand.Op) { ctx.VPERM2I128(i, my, y, y1) } 22060 22061// VPERMD: Permute Doubleword Integers. 22062// 22063// Forms: 22064// 22065// VPERMD ymm ymm ymm 22066// VPERMD m256 ymm ymm 22067// Construct and append a VPERMD instruction to the active function. 22068func (c *Context) VPERMD(my, y, y1 operand.Op) { 22069 if inst, err := x86.VPERMD(my, y, y1); err == nil { 22070 c.Instruction(inst) 22071 } else { 22072 c.adderror(err) 22073 } 22074} 22075 22076// VPERMD: Permute Doubleword Integers. 22077// 22078// Forms: 22079// 22080// VPERMD ymm ymm ymm 22081// VPERMD m256 ymm ymm 22082// Construct and append a VPERMD instruction to the active function. 22083// Operates on the global context. 22084func VPERMD(my, y, y1 operand.Op) { ctx.VPERMD(my, y, y1) } 22085 22086// VPERMILPD: Permute Double-Precision Floating-Point Values. 22087// 22088// Forms: 22089// 22090// VPERMILPD imm8 xmm xmm 22091// VPERMILPD xmm xmm xmm 22092// VPERMILPD m128 xmm xmm 22093// VPERMILPD imm8 m128 xmm 22094// VPERMILPD imm8 ymm ymm 22095// VPERMILPD ymm ymm ymm 22096// VPERMILPD m256 ymm ymm 22097// VPERMILPD imm8 m256 ymm 22098// Construct and append a VPERMILPD instruction to the active function. 22099func (c *Context) VPERMILPD(imxy, mxy, xy operand.Op) { 22100 if inst, err := x86.VPERMILPD(imxy, mxy, xy); err == nil { 22101 c.Instruction(inst) 22102 } else { 22103 c.adderror(err) 22104 } 22105} 22106 22107// VPERMILPD: Permute Double-Precision Floating-Point Values. 22108// 22109// Forms: 22110// 22111// VPERMILPD imm8 xmm xmm 22112// VPERMILPD xmm xmm xmm 22113// VPERMILPD m128 xmm xmm 22114// VPERMILPD imm8 m128 xmm 22115// VPERMILPD imm8 ymm ymm 22116// VPERMILPD ymm ymm ymm 22117// VPERMILPD m256 ymm ymm 22118// VPERMILPD imm8 m256 ymm 22119// Construct and append a VPERMILPD instruction to the active function. 22120// Operates on the global context. 22121func VPERMILPD(imxy, mxy, xy operand.Op) { ctx.VPERMILPD(imxy, mxy, xy) } 22122 22123// VPERMILPS: Permute Single-Precision Floating-Point Values. 22124// 22125// Forms: 22126// 22127// VPERMILPS imm8 xmm xmm 22128// VPERMILPS xmm xmm xmm 22129// VPERMILPS m128 xmm xmm 22130// VPERMILPS imm8 m128 xmm 22131// VPERMILPS imm8 ymm ymm 22132// VPERMILPS ymm ymm ymm 22133// VPERMILPS m256 ymm ymm 22134// VPERMILPS imm8 m256 ymm 22135// Construct and append a VPERMILPS instruction to the active function. 22136func (c *Context) VPERMILPS(imxy, mxy, xy operand.Op) { 22137 if inst, err := x86.VPERMILPS(imxy, mxy, xy); err == nil { 22138 c.Instruction(inst) 22139 } else { 22140 c.adderror(err) 22141 } 22142} 22143 22144// VPERMILPS: Permute Single-Precision Floating-Point Values. 22145// 22146// Forms: 22147// 22148// VPERMILPS imm8 xmm xmm 22149// VPERMILPS xmm xmm xmm 22150// VPERMILPS m128 xmm xmm 22151// VPERMILPS imm8 m128 xmm 22152// VPERMILPS imm8 ymm ymm 22153// VPERMILPS ymm ymm ymm 22154// VPERMILPS m256 ymm ymm 22155// VPERMILPS imm8 m256 ymm 22156// Construct and append a VPERMILPS instruction to the active function. 22157// Operates on the global context. 22158func VPERMILPS(imxy, mxy, xy operand.Op) { ctx.VPERMILPS(imxy, mxy, xy) } 22159 22160// VPERMPD: Permute Double-Precision Floating-Point Elements. 22161// 22162// Forms: 22163// 22164// VPERMPD imm8 ymm ymm 22165// VPERMPD imm8 m256 ymm 22166// Construct and append a VPERMPD instruction to the active function. 22167func (c *Context) VPERMPD(i, my, y operand.Op) { 22168 if inst, err := x86.VPERMPD(i, my, y); err == nil { 22169 c.Instruction(inst) 22170 } else { 22171 c.adderror(err) 22172 } 22173} 22174 22175// VPERMPD: Permute Double-Precision Floating-Point Elements. 22176// 22177// Forms: 22178// 22179// VPERMPD imm8 ymm ymm 22180// VPERMPD imm8 m256 ymm 22181// Construct and append a VPERMPD instruction to the active function. 22182// Operates on the global context. 22183func VPERMPD(i, my, y operand.Op) { ctx.VPERMPD(i, my, y) } 22184 22185// VPERMPS: Permute Single-Precision Floating-Point Elements. 22186// 22187// Forms: 22188// 22189// VPERMPS ymm ymm ymm 22190// VPERMPS m256 ymm ymm 22191// Construct and append a VPERMPS instruction to the active function. 22192func (c *Context) VPERMPS(my, y, y1 operand.Op) { 22193 if inst, err := x86.VPERMPS(my, y, y1); err == nil { 22194 c.Instruction(inst) 22195 } else { 22196 c.adderror(err) 22197 } 22198} 22199 22200// VPERMPS: Permute Single-Precision Floating-Point Elements. 22201// 22202// Forms: 22203// 22204// VPERMPS ymm ymm ymm 22205// VPERMPS m256 ymm ymm 22206// Construct and append a VPERMPS instruction to the active function. 22207// Operates on the global context. 22208func VPERMPS(my, y, y1 operand.Op) { ctx.VPERMPS(my, y, y1) } 22209 22210// VPERMQ: Permute Quadword Integers. 22211// 22212// Forms: 22213// 22214// VPERMQ imm8 ymm ymm 22215// VPERMQ imm8 m256 ymm 22216// Construct and append a VPERMQ instruction to the active function. 22217func (c *Context) VPERMQ(i, my, y operand.Op) { 22218 if inst, err := x86.VPERMQ(i, my, y); err == nil { 22219 c.Instruction(inst) 22220 } else { 22221 c.adderror(err) 22222 } 22223} 22224 22225// VPERMQ: Permute Quadword Integers. 22226// 22227// Forms: 22228// 22229// VPERMQ imm8 ymm ymm 22230// VPERMQ imm8 m256 ymm 22231// Construct and append a VPERMQ instruction to the active function. 22232// Operates on the global context. 22233func VPERMQ(i, my, y operand.Op) { ctx.VPERMQ(i, my, y) } 22234 22235// VPEXTRB: Extract Byte. 22236// 22237// Forms: 22238// 22239// VPEXTRB imm8 xmm r32 22240// VPEXTRB imm8 xmm m8 22241// Construct and append a VPEXTRB instruction to the active function. 22242func (c *Context) VPEXTRB(i, x, mr operand.Op) { 22243 if inst, err := x86.VPEXTRB(i, x, mr); err == nil { 22244 c.Instruction(inst) 22245 } else { 22246 c.adderror(err) 22247 } 22248} 22249 22250// VPEXTRB: Extract Byte. 22251// 22252// Forms: 22253// 22254// VPEXTRB imm8 xmm r32 22255// VPEXTRB imm8 xmm m8 22256// Construct and append a VPEXTRB instruction to the active function. 22257// Operates on the global context. 22258func VPEXTRB(i, x, mr operand.Op) { ctx.VPEXTRB(i, x, mr) } 22259 22260// VPEXTRD: Extract Doubleword. 22261// 22262// Forms: 22263// 22264// VPEXTRD imm8 xmm r32 22265// VPEXTRD imm8 xmm m32 22266// Construct and append a VPEXTRD instruction to the active function. 22267func (c *Context) VPEXTRD(i, x, mr operand.Op) { 22268 if inst, err := x86.VPEXTRD(i, x, mr); err == nil { 22269 c.Instruction(inst) 22270 } else { 22271 c.adderror(err) 22272 } 22273} 22274 22275// VPEXTRD: Extract Doubleword. 22276// 22277// Forms: 22278// 22279// VPEXTRD imm8 xmm r32 22280// VPEXTRD imm8 xmm m32 22281// Construct and append a VPEXTRD instruction to the active function. 22282// Operates on the global context. 22283func VPEXTRD(i, x, mr operand.Op) { ctx.VPEXTRD(i, x, mr) } 22284 22285// VPEXTRQ: Extract Quadword. 22286// 22287// Forms: 22288// 22289// VPEXTRQ imm8 xmm r64 22290// VPEXTRQ imm8 xmm m64 22291// Construct and append a VPEXTRQ instruction to the active function. 22292func (c *Context) VPEXTRQ(i, x, mr operand.Op) { 22293 if inst, err := x86.VPEXTRQ(i, x, mr); err == nil { 22294 c.Instruction(inst) 22295 } else { 22296 c.adderror(err) 22297 } 22298} 22299 22300// VPEXTRQ: Extract Quadword. 22301// 22302// Forms: 22303// 22304// VPEXTRQ imm8 xmm r64 22305// VPEXTRQ imm8 xmm m64 22306// Construct and append a VPEXTRQ instruction to the active function. 22307// Operates on the global context. 22308func VPEXTRQ(i, x, mr operand.Op) { ctx.VPEXTRQ(i, x, mr) } 22309 22310// VPEXTRW: Extract Word. 22311// 22312// Forms: 22313// 22314// VPEXTRW imm8 xmm r32 22315// VPEXTRW imm8 xmm m16 22316// Construct and append a VPEXTRW instruction to the active function. 22317func (c *Context) VPEXTRW(i, x, mr operand.Op) { 22318 if inst, err := x86.VPEXTRW(i, x, mr); err == nil { 22319 c.Instruction(inst) 22320 } else { 22321 c.adderror(err) 22322 } 22323} 22324 22325// VPEXTRW: Extract Word. 22326// 22327// Forms: 22328// 22329// VPEXTRW imm8 xmm r32 22330// VPEXTRW imm8 xmm m16 22331// Construct and append a VPEXTRW instruction to the active function. 22332// Operates on the global context. 22333func VPEXTRW(i, x, mr operand.Op) { ctx.VPEXTRW(i, x, mr) } 22334 22335// VPGATHERDD: Gather Packed Doubleword Values Using Signed Doubleword Indices. 22336// 22337// Forms: 22338// 22339// VPGATHERDD xmm vm32x xmm 22340// VPGATHERDD ymm vm32y ymm 22341// Construct and append a VPGATHERDD instruction to the active function. 22342func (c *Context) VPGATHERDD(xy, v, xy1 operand.Op) { 22343 if inst, err := x86.VPGATHERDD(xy, v, xy1); err == nil { 22344 c.Instruction(inst) 22345 } else { 22346 c.adderror(err) 22347 } 22348} 22349 22350// VPGATHERDD: Gather Packed Doubleword Values Using Signed Doubleword Indices. 22351// 22352// Forms: 22353// 22354// VPGATHERDD xmm vm32x xmm 22355// VPGATHERDD ymm vm32y ymm 22356// Construct and append a VPGATHERDD instruction to the active function. 22357// Operates on the global context. 22358func VPGATHERDD(xy, v, xy1 operand.Op) { ctx.VPGATHERDD(xy, v, xy1) } 22359 22360// VPGATHERDQ: Gather Packed Quadword Values Using Signed Doubleword Indices. 22361// 22362// Forms: 22363// 22364// VPGATHERDQ xmm vm32x xmm 22365// VPGATHERDQ ymm vm32x ymm 22366// Construct and append a VPGATHERDQ instruction to the active function. 22367func (c *Context) VPGATHERDQ(xy, v, xy1 operand.Op) { 22368 if inst, err := x86.VPGATHERDQ(xy, v, xy1); err == nil { 22369 c.Instruction(inst) 22370 } else { 22371 c.adderror(err) 22372 } 22373} 22374 22375// VPGATHERDQ: Gather Packed Quadword Values Using Signed Doubleword Indices. 22376// 22377// Forms: 22378// 22379// VPGATHERDQ xmm vm32x xmm 22380// VPGATHERDQ ymm vm32x ymm 22381// Construct and append a VPGATHERDQ instruction to the active function. 22382// Operates on the global context. 22383func VPGATHERDQ(xy, v, xy1 operand.Op) { ctx.VPGATHERDQ(xy, v, xy1) } 22384 22385// VPGATHERQD: Gather Packed Doubleword Values Using Signed Quadword Indices. 22386// 22387// Forms: 22388// 22389// VPGATHERQD xmm vm64x xmm 22390// VPGATHERQD xmm vm64y xmm 22391// Construct and append a VPGATHERQD instruction to the active function. 22392func (c *Context) VPGATHERQD(x, v, x1 operand.Op) { 22393 if inst, err := x86.VPGATHERQD(x, v, x1); err == nil { 22394 c.Instruction(inst) 22395 } else { 22396 c.adderror(err) 22397 } 22398} 22399 22400// VPGATHERQD: Gather Packed Doubleword Values Using Signed Quadword Indices. 22401// 22402// Forms: 22403// 22404// VPGATHERQD xmm vm64x xmm 22405// VPGATHERQD xmm vm64y xmm 22406// Construct and append a VPGATHERQD instruction to the active function. 22407// Operates on the global context. 22408func VPGATHERQD(x, v, x1 operand.Op) { ctx.VPGATHERQD(x, v, x1) } 22409 22410// VPGATHERQQ: Gather Packed Quadword Values Using Signed Quadword Indices. 22411// 22412// Forms: 22413// 22414// VPGATHERQQ xmm vm64x xmm 22415// VPGATHERQQ ymm vm64y ymm 22416// Construct and append a VPGATHERQQ instruction to the active function. 22417func (c *Context) VPGATHERQQ(xy, v, xy1 operand.Op) { 22418 if inst, err := x86.VPGATHERQQ(xy, v, xy1); err == nil { 22419 c.Instruction(inst) 22420 } else { 22421 c.adderror(err) 22422 } 22423} 22424 22425// VPGATHERQQ: Gather Packed Quadword Values Using Signed Quadword Indices. 22426// 22427// Forms: 22428// 22429// VPGATHERQQ xmm vm64x xmm 22430// VPGATHERQQ ymm vm64y ymm 22431// Construct and append a VPGATHERQQ instruction to the active function. 22432// Operates on the global context. 22433func VPGATHERQQ(xy, v, xy1 operand.Op) { ctx.VPGATHERQQ(xy, v, xy1) } 22434 22435// VPHADDD: Packed Horizontal Add Doubleword Integer. 22436// 22437// Forms: 22438// 22439// VPHADDD xmm xmm xmm 22440// VPHADDD m128 xmm xmm 22441// VPHADDD ymm ymm ymm 22442// VPHADDD m256 ymm ymm 22443// Construct and append a VPHADDD instruction to the active function. 22444func (c *Context) VPHADDD(mxy, xy, xy1 operand.Op) { 22445 if inst, err := x86.VPHADDD(mxy, xy, xy1); err == nil { 22446 c.Instruction(inst) 22447 } else { 22448 c.adderror(err) 22449 } 22450} 22451 22452// VPHADDD: Packed Horizontal Add Doubleword Integer. 22453// 22454// Forms: 22455// 22456// VPHADDD xmm xmm xmm 22457// VPHADDD m128 xmm xmm 22458// VPHADDD ymm ymm ymm 22459// VPHADDD m256 ymm ymm 22460// Construct and append a VPHADDD instruction to the active function. 22461// Operates on the global context. 22462func VPHADDD(mxy, xy, xy1 operand.Op) { ctx.VPHADDD(mxy, xy, xy1) } 22463 22464// VPHADDSW: Packed Horizontal Add Signed Word Integers with Signed Saturation. 22465// 22466// Forms: 22467// 22468// VPHADDSW xmm xmm xmm 22469// VPHADDSW m128 xmm xmm 22470// VPHADDSW ymm ymm ymm 22471// VPHADDSW m256 ymm ymm 22472// Construct and append a VPHADDSW instruction to the active function. 22473func (c *Context) VPHADDSW(mxy, xy, xy1 operand.Op) { 22474 if inst, err := x86.VPHADDSW(mxy, xy, xy1); err == nil { 22475 c.Instruction(inst) 22476 } else { 22477 c.adderror(err) 22478 } 22479} 22480 22481// VPHADDSW: Packed Horizontal Add Signed Word Integers with Signed Saturation. 22482// 22483// Forms: 22484// 22485// VPHADDSW xmm xmm xmm 22486// VPHADDSW m128 xmm xmm 22487// VPHADDSW ymm ymm ymm 22488// VPHADDSW m256 ymm ymm 22489// Construct and append a VPHADDSW instruction to the active function. 22490// Operates on the global context. 22491func VPHADDSW(mxy, xy, xy1 operand.Op) { ctx.VPHADDSW(mxy, xy, xy1) } 22492 22493// VPHADDW: Packed Horizontal Add Word Integers. 22494// 22495// Forms: 22496// 22497// VPHADDW xmm xmm xmm 22498// VPHADDW m128 xmm xmm 22499// VPHADDW ymm ymm ymm 22500// VPHADDW m256 ymm ymm 22501// Construct and append a VPHADDW instruction to the active function. 22502func (c *Context) VPHADDW(mxy, xy, xy1 operand.Op) { 22503 if inst, err := x86.VPHADDW(mxy, xy, xy1); err == nil { 22504 c.Instruction(inst) 22505 } else { 22506 c.adderror(err) 22507 } 22508} 22509 22510// VPHADDW: Packed Horizontal Add Word Integers. 22511// 22512// Forms: 22513// 22514// VPHADDW xmm xmm xmm 22515// VPHADDW m128 xmm xmm 22516// VPHADDW ymm ymm ymm 22517// VPHADDW m256 ymm ymm 22518// Construct and append a VPHADDW instruction to the active function. 22519// Operates on the global context. 22520func VPHADDW(mxy, xy, xy1 operand.Op) { ctx.VPHADDW(mxy, xy, xy1) } 22521 22522// VPHMINPOSUW: Packed Horizontal Minimum of Unsigned Word Integers. 22523// 22524// Forms: 22525// 22526// VPHMINPOSUW xmm xmm 22527// VPHMINPOSUW m128 xmm 22528// Construct and append a VPHMINPOSUW instruction to the active function. 22529func (c *Context) VPHMINPOSUW(mx, x operand.Op) { 22530 if inst, err := x86.VPHMINPOSUW(mx, x); err == nil { 22531 c.Instruction(inst) 22532 } else { 22533 c.adderror(err) 22534 } 22535} 22536 22537// VPHMINPOSUW: Packed Horizontal Minimum of Unsigned Word Integers. 22538// 22539// Forms: 22540// 22541// VPHMINPOSUW xmm xmm 22542// VPHMINPOSUW m128 xmm 22543// Construct and append a VPHMINPOSUW instruction to the active function. 22544// Operates on the global context. 22545func VPHMINPOSUW(mx, x operand.Op) { ctx.VPHMINPOSUW(mx, x) } 22546 22547// VPHSUBD: Packed Horizontal Subtract Doubleword Integers. 22548// 22549// Forms: 22550// 22551// VPHSUBD xmm xmm xmm 22552// VPHSUBD m128 xmm xmm 22553// VPHSUBD ymm ymm ymm 22554// VPHSUBD m256 ymm ymm 22555// Construct and append a VPHSUBD instruction to the active function. 22556func (c *Context) VPHSUBD(mxy, xy, xy1 operand.Op) { 22557 if inst, err := x86.VPHSUBD(mxy, xy, xy1); err == nil { 22558 c.Instruction(inst) 22559 } else { 22560 c.adderror(err) 22561 } 22562} 22563 22564// VPHSUBD: Packed Horizontal Subtract Doubleword Integers. 22565// 22566// Forms: 22567// 22568// VPHSUBD xmm xmm xmm 22569// VPHSUBD m128 xmm xmm 22570// VPHSUBD ymm ymm ymm 22571// VPHSUBD m256 ymm ymm 22572// Construct and append a VPHSUBD instruction to the active function. 22573// Operates on the global context. 22574func VPHSUBD(mxy, xy, xy1 operand.Op) { ctx.VPHSUBD(mxy, xy, xy1) } 22575 22576// VPHSUBSW: Packed Horizontal Subtract Signed Word Integers with Signed Saturation. 22577// 22578// Forms: 22579// 22580// VPHSUBSW xmm xmm xmm 22581// VPHSUBSW m128 xmm xmm 22582// VPHSUBSW ymm ymm ymm 22583// VPHSUBSW m256 ymm ymm 22584// Construct and append a VPHSUBSW instruction to the active function. 22585func (c *Context) VPHSUBSW(mxy, xy, xy1 operand.Op) { 22586 if inst, err := x86.VPHSUBSW(mxy, xy, xy1); err == nil { 22587 c.Instruction(inst) 22588 } else { 22589 c.adderror(err) 22590 } 22591} 22592 22593// VPHSUBSW: Packed Horizontal Subtract Signed Word Integers with Signed Saturation. 22594// 22595// Forms: 22596// 22597// VPHSUBSW xmm xmm xmm 22598// VPHSUBSW m128 xmm xmm 22599// VPHSUBSW ymm ymm ymm 22600// VPHSUBSW m256 ymm ymm 22601// Construct and append a VPHSUBSW instruction to the active function. 22602// Operates on the global context. 22603func VPHSUBSW(mxy, xy, xy1 operand.Op) { ctx.VPHSUBSW(mxy, xy, xy1) } 22604 22605// VPHSUBW: Packed Horizontal Subtract Word Integers. 22606// 22607// Forms: 22608// 22609// VPHSUBW xmm xmm xmm 22610// VPHSUBW m128 xmm xmm 22611// VPHSUBW ymm ymm ymm 22612// VPHSUBW m256 ymm ymm 22613// Construct and append a VPHSUBW instruction to the active function. 22614func (c *Context) VPHSUBW(mxy, xy, xy1 operand.Op) { 22615 if inst, err := x86.VPHSUBW(mxy, xy, xy1); err == nil { 22616 c.Instruction(inst) 22617 } else { 22618 c.adderror(err) 22619 } 22620} 22621 22622// VPHSUBW: Packed Horizontal Subtract Word Integers. 22623// 22624// Forms: 22625// 22626// VPHSUBW xmm xmm xmm 22627// VPHSUBW m128 xmm xmm 22628// VPHSUBW ymm ymm ymm 22629// VPHSUBW m256 ymm ymm 22630// Construct and append a VPHSUBW instruction to the active function. 22631// Operates on the global context. 22632func VPHSUBW(mxy, xy, xy1 operand.Op) { ctx.VPHSUBW(mxy, xy, xy1) } 22633 22634// VPINSRB: Insert Byte. 22635// 22636// Forms: 22637// 22638// VPINSRB imm8 r32 xmm xmm 22639// VPINSRB imm8 m8 xmm xmm 22640// Construct and append a VPINSRB instruction to the active function. 22641func (c *Context) VPINSRB(i, mr, x, x1 operand.Op) { 22642 if inst, err := x86.VPINSRB(i, mr, x, x1); err == nil { 22643 c.Instruction(inst) 22644 } else { 22645 c.adderror(err) 22646 } 22647} 22648 22649// VPINSRB: Insert Byte. 22650// 22651// Forms: 22652// 22653// VPINSRB imm8 r32 xmm xmm 22654// VPINSRB imm8 m8 xmm xmm 22655// Construct and append a VPINSRB instruction to the active function. 22656// Operates on the global context. 22657func VPINSRB(i, mr, x, x1 operand.Op) { ctx.VPINSRB(i, mr, x, x1) } 22658 22659// VPINSRD: Insert Doubleword. 22660// 22661// Forms: 22662// 22663// VPINSRD imm8 r32 xmm xmm 22664// VPINSRD imm8 m32 xmm xmm 22665// Construct and append a VPINSRD instruction to the active function. 22666func (c *Context) VPINSRD(i, mr, x, x1 operand.Op) { 22667 if inst, err := x86.VPINSRD(i, mr, x, x1); err == nil { 22668 c.Instruction(inst) 22669 } else { 22670 c.adderror(err) 22671 } 22672} 22673 22674// VPINSRD: Insert Doubleword. 22675// 22676// Forms: 22677// 22678// VPINSRD imm8 r32 xmm xmm 22679// VPINSRD imm8 m32 xmm xmm 22680// Construct and append a VPINSRD instruction to the active function. 22681// Operates on the global context. 22682func VPINSRD(i, mr, x, x1 operand.Op) { ctx.VPINSRD(i, mr, x, x1) } 22683 22684// VPINSRQ: Insert Quadword. 22685// 22686// Forms: 22687// 22688// VPINSRQ imm8 r64 xmm xmm 22689// VPINSRQ imm8 m64 xmm xmm 22690// Construct and append a VPINSRQ instruction to the active function. 22691func (c *Context) VPINSRQ(i, mr, x, x1 operand.Op) { 22692 if inst, err := x86.VPINSRQ(i, mr, x, x1); err == nil { 22693 c.Instruction(inst) 22694 } else { 22695 c.adderror(err) 22696 } 22697} 22698 22699// VPINSRQ: Insert Quadword. 22700// 22701// Forms: 22702// 22703// VPINSRQ imm8 r64 xmm xmm 22704// VPINSRQ imm8 m64 xmm xmm 22705// Construct and append a VPINSRQ instruction to the active function. 22706// Operates on the global context. 22707func VPINSRQ(i, mr, x, x1 operand.Op) { ctx.VPINSRQ(i, mr, x, x1) } 22708 22709// VPINSRW: Insert Word. 22710// 22711// Forms: 22712// 22713// VPINSRW imm8 r32 xmm xmm 22714// VPINSRW imm8 m16 xmm xmm 22715// Construct and append a VPINSRW instruction to the active function. 22716func (c *Context) VPINSRW(i, mr, x, x1 operand.Op) { 22717 if inst, err := x86.VPINSRW(i, mr, x, x1); err == nil { 22718 c.Instruction(inst) 22719 } else { 22720 c.adderror(err) 22721 } 22722} 22723 22724// VPINSRW: Insert Word. 22725// 22726// Forms: 22727// 22728// VPINSRW imm8 r32 xmm xmm 22729// VPINSRW imm8 m16 xmm xmm 22730// Construct and append a VPINSRW instruction to the active function. 22731// Operates on the global context. 22732func VPINSRW(i, mr, x, x1 operand.Op) { ctx.VPINSRW(i, mr, x, x1) } 22733 22734// VPMADDUBSW: Multiply and Add Packed Signed and Unsigned Byte Integers. 22735// 22736// Forms: 22737// 22738// VPMADDUBSW xmm xmm xmm 22739// VPMADDUBSW m128 xmm xmm 22740// VPMADDUBSW ymm ymm ymm 22741// VPMADDUBSW m256 ymm ymm 22742// Construct and append a VPMADDUBSW instruction to the active function. 22743func (c *Context) VPMADDUBSW(mxy, xy, xy1 operand.Op) { 22744 if inst, err := x86.VPMADDUBSW(mxy, xy, xy1); err == nil { 22745 c.Instruction(inst) 22746 } else { 22747 c.adderror(err) 22748 } 22749} 22750 22751// VPMADDUBSW: Multiply and Add Packed Signed and Unsigned Byte Integers. 22752// 22753// Forms: 22754// 22755// VPMADDUBSW xmm xmm xmm 22756// VPMADDUBSW m128 xmm xmm 22757// VPMADDUBSW ymm ymm ymm 22758// VPMADDUBSW m256 ymm ymm 22759// Construct and append a VPMADDUBSW instruction to the active function. 22760// Operates on the global context. 22761func VPMADDUBSW(mxy, xy, xy1 operand.Op) { ctx.VPMADDUBSW(mxy, xy, xy1) } 22762 22763// VPMADDWD: Multiply and Add Packed Signed Word Integers. 22764// 22765// Forms: 22766// 22767// VPMADDWD xmm xmm xmm 22768// VPMADDWD m128 xmm xmm 22769// VPMADDWD ymm ymm ymm 22770// VPMADDWD m256 ymm ymm 22771// Construct and append a VPMADDWD instruction to the active function. 22772func (c *Context) VPMADDWD(mxy, xy, xy1 operand.Op) { 22773 if inst, err := x86.VPMADDWD(mxy, xy, xy1); err == nil { 22774 c.Instruction(inst) 22775 } else { 22776 c.adderror(err) 22777 } 22778} 22779 22780// VPMADDWD: Multiply and Add Packed Signed Word Integers. 22781// 22782// Forms: 22783// 22784// VPMADDWD xmm xmm xmm 22785// VPMADDWD m128 xmm xmm 22786// VPMADDWD ymm ymm ymm 22787// VPMADDWD m256 ymm ymm 22788// Construct and append a VPMADDWD instruction to the active function. 22789// Operates on the global context. 22790func VPMADDWD(mxy, xy, xy1 operand.Op) { ctx.VPMADDWD(mxy, xy, xy1) } 22791 22792// VPMASKMOVD: Conditional Move Packed Doubleword Integers. 22793// 22794// Forms: 22795// 22796// VPMASKMOVD m128 xmm xmm 22797// VPMASKMOVD m256 ymm ymm 22798// VPMASKMOVD xmm xmm m128 22799// VPMASKMOVD ymm ymm m256 22800// Construct and append a VPMASKMOVD instruction to the active function. 22801func (c *Context) VPMASKMOVD(mxy, xy, mxy1 operand.Op) { 22802 if inst, err := x86.VPMASKMOVD(mxy, xy, mxy1); err == nil { 22803 c.Instruction(inst) 22804 } else { 22805 c.adderror(err) 22806 } 22807} 22808 22809// VPMASKMOVD: Conditional Move Packed Doubleword Integers. 22810// 22811// Forms: 22812// 22813// VPMASKMOVD m128 xmm xmm 22814// VPMASKMOVD m256 ymm ymm 22815// VPMASKMOVD xmm xmm m128 22816// VPMASKMOVD ymm ymm m256 22817// Construct and append a VPMASKMOVD instruction to the active function. 22818// Operates on the global context. 22819func VPMASKMOVD(mxy, xy, mxy1 operand.Op) { ctx.VPMASKMOVD(mxy, xy, mxy1) } 22820 22821// VPMASKMOVQ: Conditional Move Packed Quadword Integers. 22822// 22823// Forms: 22824// 22825// VPMASKMOVQ m128 xmm xmm 22826// VPMASKMOVQ m256 ymm ymm 22827// VPMASKMOVQ xmm xmm m128 22828// VPMASKMOVQ ymm ymm m256 22829// Construct and append a VPMASKMOVQ instruction to the active function. 22830func (c *Context) VPMASKMOVQ(mxy, xy, mxy1 operand.Op) { 22831 if inst, err := x86.VPMASKMOVQ(mxy, xy, mxy1); err == nil { 22832 c.Instruction(inst) 22833 } else { 22834 c.adderror(err) 22835 } 22836} 22837 22838// VPMASKMOVQ: Conditional Move Packed Quadword Integers. 22839// 22840// Forms: 22841// 22842// VPMASKMOVQ m128 xmm xmm 22843// VPMASKMOVQ m256 ymm ymm 22844// VPMASKMOVQ xmm xmm m128 22845// VPMASKMOVQ ymm ymm m256 22846// Construct and append a VPMASKMOVQ instruction to the active function. 22847// Operates on the global context. 22848func VPMASKMOVQ(mxy, xy, mxy1 operand.Op) { ctx.VPMASKMOVQ(mxy, xy, mxy1) } 22849 22850// VPMAXSB: Maximum of Packed Signed Byte Integers. 22851// 22852// Forms: 22853// 22854// VPMAXSB xmm xmm xmm 22855// VPMAXSB m128 xmm xmm 22856// VPMAXSB ymm ymm ymm 22857// VPMAXSB m256 ymm ymm 22858// Construct and append a VPMAXSB instruction to the active function. 22859func (c *Context) VPMAXSB(mxy, xy, xy1 operand.Op) { 22860 if inst, err := x86.VPMAXSB(mxy, xy, xy1); err == nil { 22861 c.Instruction(inst) 22862 } else { 22863 c.adderror(err) 22864 } 22865} 22866 22867// VPMAXSB: Maximum of Packed Signed Byte Integers. 22868// 22869// Forms: 22870// 22871// VPMAXSB xmm xmm xmm 22872// VPMAXSB m128 xmm xmm 22873// VPMAXSB ymm ymm ymm 22874// VPMAXSB m256 ymm ymm 22875// Construct and append a VPMAXSB instruction to the active function. 22876// Operates on the global context. 22877func VPMAXSB(mxy, xy, xy1 operand.Op) { ctx.VPMAXSB(mxy, xy, xy1) } 22878 22879// VPMAXSD: Maximum of Packed Signed Doubleword Integers. 22880// 22881// Forms: 22882// 22883// VPMAXSD xmm xmm xmm 22884// VPMAXSD m128 xmm xmm 22885// VPMAXSD ymm ymm ymm 22886// VPMAXSD m256 ymm ymm 22887// Construct and append a VPMAXSD instruction to the active function. 22888func (c *Context) VPMAXSD(mxy, xy, xy1 operand.Op) { 22889 if inst, err := x86.VPMAXSD(mxy, xy, xy1); err == nil { 22890 c.Instruction(inst) 22891 } else { 22892 c.adderror(err) 22893 } 22894} 22895 22896// VPMAXSD: Maximum of Packed Signed Doubleword Integers. 22897// 22898// Forms: 22899// 22900// VPMAXSD xmm xmm xmm 22901// VPMAXSD m128 xmm xmm 22902// VPMAXSD ymm ymm ymm 22903// VPMAXSD m256 ymm ymm 22904// Construct and append a VPMAXSD instruction to the active function. 22905// Operates on the global context. 22906func VPMAXSD(mxy, xy, xy1 operand.Op) { ctx.VPMAXSD(mxy, xy, xy1) } 22907 22908// VPMAXSW: Maximum of Packed Signed Word Integers. 22909// 22910// Forms: 22911// 22912// VPMAXSW xmm xmm xmm 22913// VPMAXSW m128 xmm xmm 22914// VPMAXSW ymm ymm ymm 22915// VPMAXSW m256 ymm ymm 22916// Construct and append a VPMAXSW instruction to the active function. 22917func (c *Context) VPMAXSW(mxy, xy, xy1 operand.Op) { 22918 if inst, err := x86.VPMAXSW(mxy, xy, xy1); err == nil { 22919 c.Instruction(inst) 22920 } else { 22921 c.adderror(err) 22922 } 22923} 22924 22925// VPMAXSW: Maximum of Packed Signed Word Integers. 22926// 22927// Forms: 22928// 22929// VPMAXSW xmm xmm xmm 22930// VPMAXSW m128 xmm xmm 22931// VPMAXSW ymm ymm ymm 22932// VPMAXSW m256 ymm ymm 22933// Construct and append a VPMAXSW instruction to the active function. 22934// Operates on the global context. 22935func VPMAXSW(mxy, xy, xy1 operand.Op) { ctx.VPMAXSW(mxy, xy, xy1) } 22936 22937// VPMAXUB: Maximum of Packed Unsigned Byte Integers. 22938// 22939// Forms: 22940// 22941// VPMAXUB xmm xmm xmm 22942// VPMAXUB m128 xmm xmm 22943// VPMAXUB ymm ymm ymm 22944// VPMAXUB m256 ymm ymm 22945// Construct and append a VPMAXUB instruction to the active function. 22946func (c *Context) VPMAXUB(mxy, xy, xy1 operand.Op) { 22947 if inst, err := x86.VPMAXUB(mxy, xy, xy1); err == nil { 22948 c.Instruction(inst) 22949 } else { 22950 c.adderror(err) 22951 } 22952} 22953 22954// VPMAXUB: Maximum of Packed Unsigned Byte Integers. 22955// 22956// Forms: 22957// 22958// VPMAXUB xmm xmm xmm 22959// VPMAXUB m128 xmm xmm 22960// VPMAXUB ymm ymm ymm 22961// VPMAXUB m256 ymm ymm 22962// Construct and append a VPMAXUB instruction to the active function. 22963// Operates on the global context. 22964func VPMAXUB(mxy, xy, xy1 operand.Op) { ctx.VPMAXUB(mxy, xy, xy1) } 22965 22966// VPMAXUD: Maximum of Packed Unsigned Doubleword Integers. 22967// 22968// Forms: 22969// 22970// VPMAXUD xmm xmm xmm 22971// VPMAXUD m128 xmm xmm 22972// VPMAXUD ymm ymm ymm 22973// VPMAXUD m256 ymm ymm 22974// Construct and append a VPMAXUD instruction to the active function. 22975func (c *Context) VPMAXUD(mxy, xy, xy1 operand.Op) { 22976 if inst, err := x86.VPMAXUD(mxy, xy, xy1); err == nil { 22977 c.Instruction(inst) 22978 } else { 22979 c.adderror(err) 22980 } 22981} 22982 22983// VPMAXUD: Maximum of Packed Unsigned Doubleword Integers. 22984// 22985// Forms: 22986// 22987// VPMAXUD xmm xmm xmm 22988// VPMAXUD m128 xmm xmm 22989// VPMAXUD ymm ymm ymm 22990// VPMAXUD m256 ymm ymm 22991// Construct and append a VPMAXUD instruction to the active function. 22992// Operates on the global context. 22993func VPMAXUD(mxy, xy, xy1 operand.Op) { ctx.VPMAXUD(mxy, xy, xy1) } 22994 22995// VPMAXUW: Maximum of Packed Unsigned Word Integers. 22996// 22997// Forms: 22998// 22999// VPMAXUW xmm xmm xmm 23000// VPMAXUW m128 xmm xmm 23001// VPMAXUW ymm ymm ymm 23002// VPMAXUW m256 ymm ymm 23003// Construct and append a VPMAXUW instruction to the active function. 23004func (c *Context) VPMAXUW(mxy, xy, xy1 operand.Op) { 23005 if inst, err := x86.VPMAXUW(mxy, xy, xy1); err == nil { 23006 c.Instruction(inst) 23007 } else { 23008 c.adderror(err) 23009 } 23010} 23011 23012// VPMAXUW: Maximum of Packed Unsigned Word Integers. 23013// 23014// Forms: 23015// 23016// VPMAXUW xmm xmm xmm 23017// VPMAXUW m128 xmm xmm 23018// VPMAXUW ymm ymm ymm 23019// VPMAXUW m256 ymm ymm 23020// Construct and append a VPMAXUW instruction to the active function. 23021// Operates on the global context. 23022func VPMAXUW(mxy, xy, xy1 operand.Op) { ctx.VPMAXUW(mxy, xy, xy1) } 23023 23024// VPMINSB: Minimum of Packed Signed Byte Integers. 23025// 23026// Forms: 23027// 23028// VPMINSB xmm xmm xmm 23029// VPMINSB m128 xmm xmm 23030// VPMINSB ymm ymm ymm 23031// VPMINSB m256 ymm ymm 23032// Construct and append a VPMINSB instruction to the active function. 23033func (c *Context) VPMINSB(mxy, xy, xy1 operand.Op) { 23034 if inst, err := x86.VPMINSB(mxy, xy, xy1); err == nil { 23035 c.Instruction(inst) 23036 } else { 23037 c.adderror(err) 23038 } 23039} 23040 23041// VPMINSB: Minimum of Packed Signed Byte Integers. 23042// 23043// Forms: 23044// 23045// VPMINSB xmm xmm xmm 23046// VPMINSB m128 xmm xmm 23047// VPMINSB ymm ymm ymm 23048// VPMINSB m256 ymm ymm 23049// Construct and append a VPMINSB instruction to the active function. 23050// Operates on the global context. 23051func VPMINSB(mxy, xy, xy1 operand.Op) { ctx.VPMINSB(mxy, xy, xy1) } 23052 23053// VPMINSD: Minimum of Packed Signed Doubleword Integers. 23054// 23055// Forms: 23056// 23057// VPMINSD xmm xmm xmm 23058// VPMINSD m128 xmm xmm 23059// VPMINSD ymm ymm ymm 23060// VPMINSD m256 ymm ymm 23061// Construct and append a VPMINSD instruction to the active function. 23062func (c *Context) VPMINSD(mxy, xy, xy1 operand.Op) { 23063 if inst, err := x86.VPMINSD(mxy, xy, xy1); err == nil { 23064 c.Instruction(inst) 23065 } else { 23066 c.adderror(err) 23067 } 23068} 23069 23070// VPMINSD: Minimum of Packed Signed Doubleword Integers. 23071// 23072// Forms: 23073// 23074// VPMINSD xmm xmm xmm 23075// VPMINSD m128 xmm xmm 23076// VPMINSD ymm ymm ymm 23077// VPMINSD m256 ymm ymm 23078// Construct and append a VPMINSD instruction to the active function. 23079// Operates on the global context. 23080func VPMINSD(mxy, xy, xy1 operand.Op) { ctx.VPMINSD(mxy, xy, xy1) } 23081 23082// VPMINSW: Minimum of Packed Signed Word Integers. 23083// 23084// Forms: 23085// 23086// VPMINSW xmm xmm xmm 23087// VPMINSW m128 xmm xmm 23088// VPMINSW ymm ymm ymm 23089// VPMINSW m256 ymm ymm 23090// Construct and append a VPMINSW instruction to the active function. 23091func (c *Context) VPMINSW(mxy, xy, xy1 operand.Op) { 23092 if inst, err := x86.VPMINSW(mxy, xy, xy1); err == nil { 23093 c.Instruction(inst) 23094 } else { 23095 c.adderror(err) 23096 } 23097} 23098 23099// VPMINSW: Minimum of Packed Signed Word Integers. 23100// 23101// Forms: 23102// 23103// VPMINSW xmm xmm xmm 23104// VPMINSW m128 xmm xmm 23105// VPMINSW ymm ymm ymm 23106// VPMINSW m256 ymm ymm 23107// Construct and append a VPMINSW instruction to the active function. 23108// Operates on the global context. 23109func VPMINSW(mxy, xy, xy1 operand.Op) { ctx.VPMINSW(mxy, xy, xy1) } 23110 23111// VPMINUB: Minimum of Packed Unsigned Byte Integers. 23112// 23113// Forms: 23114// 23115// VPMINUB xmm xmm xmm 23116// VPMINUB m128 xmm xmm 23117// VPMINUB ymm ymm ymm 23118// VPMINUB m256 ymm ymm 23119// Construct and append a VPMINUB instruction to the active function. 23120func (c *Context) VPMINUB(mxy, xy, xy1 operand.Op) { 23121 if inst, err := x86.VPMINUB(mxy, xy, xy1); err == nil { 23122 c.Instruction(inst) 23123 } else { 23124 c.adderror(err) 23125 } 23126} 23127 23128// VPMINUB: Minimum of Packed Unsigned Byte Integers. 23129// 23130// Forms: 23131// 23132// VPMINUB xmm xmm xmm 23133// VPMINUB m128 xmm xmm 23134// VPMINUB ymm ymm ymm 23135// VPMINUB m256 ymm ymm 23136// Construct and append a VPMINUB instruction to the active function. 23137// Operates on the global context. 23138func VPMINUB(mxy, xy, xy1 operand.Op) { ctx.VPMINUB(mxy, xy, xy1) } 23139 23140// VPMINUD: Minimum of Packed Unsigned Doubleword Integers. 23141// 23142// Forms: 23143// 23144// VPMINUD xmm xmm xmm 23145// VPMINUD m128 xmm xmm 23146// VPMINUD ymm ymm ymm 23147// VPMINUD m256 ymm ymm 23148// Construct and append a VPMINUD instruction to the active function. 23149func (c *Context) VPMINUD(mxy, xy, xy1 operand.Op) { 23150 if inst, err := x86.VPMINUD(mxy, xy, xy1); err == nil { 23151 c.Instruction(inst) 23152 } else { 23153 c.adderror(err) 23154 } 23155} 23156 23157// VPMINUD: Minimum of Packed Unsigned Doubleword Integers. 23158// 23159// Forms: 23160// 23161// VPMINUD xmm xmm xmm 23162// VPMINUD m128 xmm xmm 23163// VPMINUD ymm ymm ymm 23164// VPMINUD m256 ymm ymm 23165// Construct and append a VPMINUD instruction to the active function. 23166// Operates on the global context. 23167func VPMINUD(mxy, xy, xy1 operand.Op) { ctx.VPMINUD(mxy, xy, xy1) } 23168 23169// VPMINUW: Minimum of Packed Unsigned Word Integers. 23170// 23171// Forms: 23172// 23173// VPMINUW xmm xmm xmm 23174// VPMINUW m128 xmm xmm 23175// VPMINUW ymm ymm ymm 23176// VPMINUW m256 ymm ymm 23177// Construct and append a VPMINUW instruction to the active function. 23178func (c *Context) VPMINUW(mxy, xy, xy1 operand.Op) { 23179 if inst, err := x86.VPMINUW(mxy, xy, xy1); err == nil { 23180 c.Instruction(inst) 23181 } else { 23182 c.adderror(err) 23183 } 23184} 23185 23186// VPMINUW: Minimum of Packed Unsigned Word Integers. 23187// 23188// Forms: 23189// 23190// VPMINUW xmm xmm xmm 23191// VPMINUW m128 xmm xmm 23192// VPMINUW ymm ymm ymm 23193// VPMINUW m256 ymm ymm 23194// Construct and append a VPMINUW instruction to the active function. 23195// Operates on the global context. 23196func VPMINUW(mxy, xy, xy1 operand.Op) { ctx.VPMINUW(mxy, xy, xy1) } 23197 23198// VPMOVMSKB: Move Byte Mask. 23199// 23200// Forms: 23201// 23202// VPMOVMSKB xmm r32 23203// VPMOVMSKB ymm r32 23204// Construct and append a VPMOVMSKB instruction to the active function. 23205func (c *Context) VPMOVMSKB(xy, r operand.Op) { 23206 if inst, err := x86.VPMOVMSKB(xy, r); err == nil { 23207 c.Instruction(inst) 23208 } else { 23209 c.adderror(err) 23210 } 23211} 23212 23213// VPMOVMSKB: Move Byte Mask. 23214// 23215// Forms: 23216// 23217// VPMOVMSKB xmm r32 23218// VPMOVMSKB ymm r32 23219// Construct and append a VPMOVMSKB instruction to the active function. 23220// Operates on the global context. 23221func VPMOVMSKB(xy, r operand.Op) { ctx.VPMOVMSKB(xy, r) } 23222 23223// VPMOVSXBD: Move Packed Byte Integers to Doubleword Integers with Sign Extension. 23224// 23225// Forms: 23226// 23227// VPMOVSXBD xmm xmm 23228// VPMOVSXBD m32 xmm 23229// VPMOVSXBD xmm ymm 23230// VPMOVSXBD m64 ymm 23231// Construct and append a VPMOVSXBD instruction to the active function. 23232func (c *Context) VPMOVSXBD(mx, xy operand.Op) { 23233 if inst, err := x86.VPMOVSXBD(mx, xy); err == nil { 23234 c.Instruction(inst) 23235 } else { 23236 c.adderror(err) 23237 } 23238} 23239 23240// VPMOVSXBD: Move Packed Byte Integers to Doubleword Integers with Sign Extension. 23241// 23242// Forms: 23243// 23244// VPMOVSXBD xmm xmm 23245// VPMOVSXBD m32 xmm 23246// VPMOVSXBD xmm ymm 23247// VPMOVSXBD m64 ymm 23248// Construct and append a VPMOVSXBD instruction to the active function. 23249// Operates on the global context. 23250func VPMOVSXBD(mx, xy operand.Op) { ctx.VPMOVSXBD(mx, xy) } 23251 23252// VPMOVSXBQ: Move Packed Byte Integers to Quadword Integers with Sign Extension. 23253// 23254// Forms: 23255// 23256// VPMOVSXBQ xmm xmm 23257// VPMOVSXBQ m16 xmm 23258// VPMOVSXBQ xmm ymm 23259// VPMOVSXBQ m32 ymm 23260// Construct and append a VPMOVSXBQ instruction to the active function. 23261func (c *Context) VPMOVSXBQ(mx, xy operand.Op) { 23262 if inst, err := x86.VPMOVSXBQ(mx, xy); err == nil { 23263 c.Instruction(inst) 23264 } else { 23265 c.adderror(err) 23266 } 23267} 23268 23269// VPMOVSXBQ: Move Packed Byte Integers to Quadword Integers with Sign Extension. 23270// 23271// Forms: 23272// 23273// VPMOVSXBQ xmm xmm 23274// VPMOVSXBQ m16 xmm 23275// VPMOVSXBQ xmm ymm 23276// VPMOVSXBQ m32 ymm 23277// Construct and append a VPMOVSXBQ instruction to the active function. 23278// Operates on the global context. 23279func VPMOVSXBQ(mx, xy operand.Op) { ctx.VPMOVSXBQ(mx, xy) } 23280 23281// VPMOVSXBW: Move Packed Byte Integers to Word Integers with Sign Extension. 23282// 23283// Forms: 23284// 23285// VPMOVSXBW xmm xmm 23286// VPMOVSXBW m64 xmm 23287// VPMOVSXBW xmm ymm 23288// VPMOVSXBW m128 ymm 23289// Construct and append a VPMOVSXBW instruction to the active function. 23290func (c *Context) VPMOVSXBW(mx, xy operand.Op) { 23291 if inst, err := x86.VPMOVSXBW(mx, xy); err == nil { 23292 c.Instruction(inst) 23293 } else { 23294 c.adderror(err) 23295 } 23296} 23297 23298// VPMOVSXBW: Move Packed Byte Integers to Word Integers with Sign Extension. 23299// 23300// Forms: 23301// 23302// VPMOVSXBW xmm xmm 23303// VPMOVSXBW m64 xmm 23304// VPMOVSXBW xmm ymm 23305// VPMOVSXBW m128 ymm 23306// Construct and append a VPMOVSXBW instruction to the active function. 23307// Operates on the global context. 23308func VPMOVSXBW(mx, xy operand.Op) { ctx.VPMOVSXBW(mx, xy) } 23309 23310// VPMOVSXDQ: Move Packed Doubleword Integers to Quadword Integers with Sign Extension. 23311// 23312// Forms: 23313// 23314// VPMOVSXDQ xmm xmm 23315// VPMOVSXDQ m64 xmm 23316// VPMOVSXDQ xmm ymm 23317// VPMOVSXDQ m128 ymm 23318// Construct and append a VPMOVSXDQ instruction to the active function. 23319func (c *Context) VPMOVSXDQ(mx, xy operand.Op) { 23320 if inst, err := x86.VPMOVSXDQ(mx, xy); err == nil { 23321 c.Instruction(inst) 23322 } else { 23323 c.adderror(err) 23324 } 23325} 23326 23327// VPMOVSXDQ: Move Packed Doubleword Integers to Quadword Integers with Sign Extension. 23328// 23329// Forms: 23330// 23331// VPMOVSXDQ xmm xmm 23332// VPMOVSXDQ m64 xmm 23333// VPMOVSXDQ xmm ymm 23334// VPMOVSXDQ m128 ymm 23335// Construct and append a VPMOVSXDQ instruction to the active function. 23336// Operates on the global context. 23337func VPMOVSXDQ(mx, xy operand.Op) { ctx.VPMOVSXDQ(mx, xy) } 23338 23339// VPMOVSXWD: Move Packed Word Integers to Doubleword Integers with Sign Extension. 23340// 23341// Forms: 23342// 23343// VPMOVSXWD xmm xmm 23344// VPMOVSXWD m64 xmm 23345// VPMOVSXWD xmm ymm 23346// VPMOVSXWD m128 ymm 23347// Construct and append a VPMOVSXWD instruction to the active function. 23348func (c *Context) VPMOVSXWD(mx, xy operand.Op) { 23349 if inst, err := x86.VPMOVSXWD(mx, xy); err == nil { 23350 c.Instruction(inst) 23351 } else { 23352 c.adderror(err) 23353 } 23354} 23355 23356// VPMOVSXWD: Move Packed Word Integers to Doubleword Integers with Sign Extension. 23357// 23358// Forms: 23359// 23360// VPMOVSXWD xmm xmm 23361// VPMOVSXWD m64 xmm 23362// VPMOVSXWD xmm ymm 23363// VPMOVSXWD m128 ymm 23364// Construct and append a VPMOVSXWD instruction to the active function. 23365// Operates on the global context. 23366func VPMOVSXWD(mx, xy operand.Op) { ctx.VPMOVSXWD(mx, xy) } 23367 23368// VPMOVSXWQ: Move Packed Word Integers to Quadword Integers with Sign Extension. 23369// 23370// Forms: 23371// 23372// VPMOVSXWQ xmm xmm 23373// VPMOVSXWQ m32 xmm 23374// VPMOVSXWQ xmm ymm 23375// VPMOVSXWQ m64 ymm 23376// Construct and append a VPMOVSXWQ instruction to the active function. 23377func (c *Context) VPMOVSXWQ(mx, xy operand.Op) { 23378 if inst, err := x86.VPMOVSXWQ(mx, xy); err == nil { 23379 c.Instruction(inst) 23380 } else { 23381 c.adderror(err) 23382 } 23383} 23384 23385// VPMOVSXWQ: Move Packed Word Integers to Quadword Integers with Sign Extension. 23386// 23387// Forms: 23388// 23389// VPMOVSXWQ xmm xmm 23390// VPMOVSXWQ m32 xmm 23391// VPMOVSXWQ xmm ymm 23392// VPMOVSXWQ m64 ymm 23393// Construct and append a VPMOVSXWQ instruction to the active function. 23394// Operates on the global context. 23395func VPMOVSXWQ(mx, xy operand.Op) { ctx.VPMOVSXWQ(mx, xy) } 23396 23397// VPMOVZXBD: Move Packed Byte Integers to Doubleword Integers with Zero Extension. 23398// 23399// Forms: 23400// 23401// VPMOVZXBD xmm xmm 23402// VPMOVZXBD m32 xmm 23403// VPMOVZXBD xmm ymm 23404// VPMOVZXBD m64 ymm 23405// Construct and append a VPMOVZXBD instruction to the active function. 23406func (c *Context) VPMOVZXBD(mx, xy operand.Op) { 23407 if inst, err := x86.VPMOVZXBD(mx, xy); err == nil { 23408 c.Instruction(inst) 23409 } else { 23410 c.adderror(err) 23411 } 23412} 23413 23414// VPMOVZXBD: Move Packed Byte Integers to Doubleword Integers with Zero Extension. 23415// 23416// Forms: 23417// 23418// VPMOVZXBD xmm xmm 23419// VPMOVZXBD m32 xmm 23420// VPMOVZXBD xmm ymm 23421// VPMOVZXBD m64 ymm 23422// Construct and append a VPMOVZXBD instruction to the active function. 23423// Operates on the global context. 23424func VPMOVZXBD(mx, xy operand.Op) { ctx.VPMOVZXBD(mx, xy) } 23425 23426// VPMOVZXBQ: Move Packed Byte Integers to Quadword Integers with Zero Extension. 23427// 23428// Forms: 23429// 23430// VPMOVZXBQ xmm xmm 23431// VPMOVZXBQ m16 xmm 23432// VPMOVZXBQ xmm ymm 23433// VPMOVZXBQ m32 ymm 23434// Construct and append a VPMOVZXBQ instruction to the active function. 23435func (c *Context) VPMOVZXBQ(mx, xy operand.Op) { 23436 if inst, err := x86.VPMOVZXBQ(mx, xy); err == nil { 23437 c.Instruction(inst) 23438 } else { 23439 c.adderror(err) 23440 } 23441} 23442 23443// VPMOVZXBQ: Move Packed Byte Integers to Quadword Integers with Zero Extension. 23444// 23445// Forms: 23446// 23447// VPMOVZXBQ xmm xmm 23448// VPMOVZXBQ m16 xmm 23449// VPMOVZXBQ xmm ymm 23450// VPMOVZXBQ m32 ymm 23451// Construct and append a VPMOVZXBQ instruction to the active function. 23452// Operates on the global context. 23453func VPMOVZXBQ(mx, xy operand.Op) { ctx.VPMOVZXBQ(mx, xy) } 23454 23455// VPMOVZXBW: Move Packed Byte Integers to Word Integers with Zero Extension. 23456// 23457// Forms: 23458// 23459// VPMOVZXBW xmm xmm 23460// VPMOVZXBW m64 xmm 23461// VPMOVZXBW xmm ymm 23462// VPMOVZXBW m128 ymm 23463// Construct and append a VPMOVZXBW instruction to the active function. 23464func (c *Context) VPMOVZXBW(mx, xy operand.Op) { 23465 if inst, err := x86.VPMOVZXBW(mx, xy); err == nil { 23466 c.Instruction(inst) 23467 } else { 23468 c.adderror(err) 23469 } 23470} 23471 23472// VPMOVZXBW: Move Packed Byte Integers to Word Integers with Zero Extension. 23473// 23474// Forms: 23475// 23476// VPMOVZXBW xmm xmm 23477// VPMOVZXBW m64 xmm 23478// VPMOVZXBW xmm ymm 23479// VPMOVZXBW m128 ymm 23480// Construct and append a VPMOVZXBW instruction to the active function. 23481// Operates on the global context. 23482func VPMOVZXBW(mx, xy operand.Op) { ctx.VPMOVZXBW(mx, xy) } 23483 23484// VPMOVZXDQ: Move Packed Doubleword Integers to Quadword Integers with Zero Extension. 23485// 23486// Forms: 23487// 23488// VPMOVZXDQ xmm xmm 23489// VPMOVZXDQ m64 xmm 23490// VPMOVZXDQ xmm ymm 23491// VPMOVZXDQ m128 ymm 23492// Construct and append a VPMOVZXDQ instruction to the active function. 23493func (c *Context) VPMOVZXDQ(mx, xy operand.Op) { 23494 if inst, err := x86.VPMOVZXDQ(mx, xy); err == nil { 23495 c.Instruction(inst) 23496 } else { 23497 c.adderror(err) 23498 } 23499} 23500 23501// VPMOVZXDQ: Move Packed Doubleword Integers to Quadword Integers with Zero Extension. 23502// 23503// Forms: 23504// 23505// VPMOVZXDQ xmm xmm 23506// VPMOVZXDQ m64 xmm 23507// VPMOVZXDQ xmm ymm 23508// VPMOVZXDQ m128 ymm 23509// Construct and append a VPMOVZXDQ instruction to the active function. 23510// Operates on the global context. 23511func VPMOVZXDQ(mx, xy operand.Op) { ctx.VPMOVZXDQ(mx, xy) } 23512 23513// VPMOVZXWD: Move Packed Word Integers to Doubleword Integers with Zero Extension. 23514// 23515// Forms: 23516// 23517// VPMOVZXWD xmm xmm 23518// VPMOVZXWD m64 xmm 23519// VPMOVZXWD xmm ymm 23520// VPMOVZXWD m128 ymm 23521// Construct and append a VPMOVZXWD instruction to the active function. 23522func (c *Context) VPMOVZXWD(mx, xy operand.Op) { 23523 if inst, err := x86.VPMOVZXWD(mx, xy); err == nil { 23524 c.Instruction(inst) 23525 } else { 23526 c.adderror(err) 23527 } 23528} 23529 23530// VPMOVZXWD: Move Packed Word Integers to Doubleword Integers with Zero Extension. 23531// 23532// Forms: 23533// 23534// VPMOVZXWD xmm xmm 23535// VPMOVZXWD m64 xmm 23536// VPMOVZXWD xmm ymm 23537// VPMOVZXWD m128 ymm 23538// Construct and append a VPMOVZXWD instruction to the active function. 23539// Operates on the global context. 23540func VPMOVZXWD(mx, xy operand.Op) { ctx.VPMOVZXWD(mx, xy) } 23541 23542// VPMOVZXWQ: Move Packed Word Integers to Quadword Integers with Zero Extension. 23543// 23544// Forms: 23545// 23546// VPMOVZXWQ xmm xmm 23547// VPMOVZXWQ m32 xmm 23548// VPMOVZXWQ xmm ymm 23549// VPMOVZXWQ m64 ymm 23550// Construct and append a VPMOVZXWQ instruction to the active function. 23551func (c *Context) VPMOVZXWQ(mx, xy operand.Op) { 23552 if inst, err := x86.VPMOVZXWQ(mx, xy); err == nil { 23553 c.Instruction(inst) 23554 } else { 23555 c.adderror(err) 23556 } 23557} 23558 23559// VPMOVZXWQ: Move Packed Word Integers to Quadword Integers with Zero Extension. 23560// 23561// Forms: 23562// 23563// VPMOVZXWQ xmm xmm 23564// VPMOVZXWQ m32 xmm 23565// VPMOVZXWQ xmm ymm 23566// VPMOVZXWQ m64 ymm 23567// Construct and append a VPMOVZXWQ instruction to the active function. 23568// Operates on the global context. 23569func VPMOVZXWQ(mx, xy operand.Op) { ctx.VPMOVZXWQ(mx, xy) } 23570 23571// VPMULDQ: Multiply Packed Signed Doubleword Integers and Store Quadword Result. 23572// 23573// Forms: 23574// 23575// VPMULDQ xmm xmm xmm 23576// VPMULDQ m128 xmm xmm 23577// VPMULDQ ymm ymm ymm 23578// VPMULDQ m256 ymm ymm 23579// Construct and append a VPMULDQ instruction to the active function. 23580func (c *Context) VPMULDQ(mxy, xy, xy1 operand.Op) { 23581 if inst, err := x86.VPMULDQ(mxy, xy, xy1); err == nil { 23582 c.Instruction(inst) 23583 } else { 23584 c.adderror(err) 23585 } 23586} 23587 23588// VPMULDQ: Multiply Packed Signed Doubleword Integers and Store Quadword Result. 23589// 23590// Forms: 23591// 23592// VPMULDQ xmm xmm xmm 23593// VPMULDQ m128 xmm xmm 23594// VPMULDQ ymm ymm ymm 23595// VPMULDQ m256 ymm ymm 23596// Construct and append a VPMULDQ instruction to the active function. 23597// Operates on the global context. 23598func VPMULDQ(mxy, xy, xy1 operand.Op) { ctx.VPMULDQ(mxy, xy, xy1) } 23599 23600// VPMULHRSW: Packed Multiply Signed Word Integers and Store High Result with Round and Scale. 23601// 23602// Forms: 23603// 23604// VPMULHRSW xmm xmm xmm 23605// VPMULHRSW m128 xmm xmm 23606// VPMULHRSW ymm ymm ymm 23607// VPMULHRSW m256 ymm ymm 23608// Construct and append a VPMULHRSW instruction to the active function. 23609func (c *Context) VPMULHRSW(mxy, xy, xy1 operand.Op) { 23610 if inst, err := x86.VPMULHRSW(mxy, xy, xy1); err == nil { 23611 c.Instruction(inst) 23612 } else { 23613 c.adderror(err) 23614 } 23615} 23616 23617// VPMULHRSW: Packed Multiply Signed Word Integers and Store High Result with Round and Scale. 23618// 23619// Forms: 23620// 23621// VPMULHRSW xmm xmm xmm 23622// VPMULHRSW m128 xmm xmm 23623// VPMULHRSW ymm ymm ymm 23624// VPMULHRSW m256 ymm ymm 23625// Construct and append a VPMULHRSW instruction to the active function. 23626// Operates on the global context. 23627func VPMULHRSW(mxy, xy, xy1 operand.Op) { ctx.VPMULHRSW(mxy, xy, xy1) } 23628 23629// VPMULHUW: Multiply Packed Unsigned Word Integers and Store High Result. 23630// 23631// Forms: 23632// 23633// VPMULHUW xmm xmm xmm 23634// VPMULHUW m128 xmm xmm 23635// VPMULHUW ymm ymm ymm 23636// VPMULHUW m256 ymm ymm 23637// Construct and append a VPMULHUW instruction to the active function. 23638func (c *Context) VPMULHUW(mxy, xy, xy1 operand.Op) { 23639 if inst, err := x86.VPMULHUW(mxy, xy, xy1); err == nil { 23640 c.Instruction(inst) 23641 } else { 23642 c.adderror(err) 23643 } 23644} 23645 23646// VPMULHUW: Multiply Packed Unsigned Word Integers and Store High Result. 23647// 23648// Forms: 23649// 23650// VPMULHUW xmm xmm xmm 23651// VPMULHUW m128 xmm xmm 23652// VPMULHUW ymm ymm ymm 23653// VPMULHUW m256 ymm ymm 23654// Construct and append a VPMULHUW instruction to the active function. 23655// Operates on the global context. 23656func VPMULHUW(mxy, xy, xy1 operand.Op) { ctx.VPMULHUW(mxy, xy, xy1) } 23657 23658// VPMULHW: Multiply Packed Signed Word Integers and Store High Result. 23659// 23660// Forms: 23661// 23662// VPMULHW xmm xmm xmm 23663// VPMULHW m128 xmm xmm 23664// VPMULHW ymm ymm ymm 23665// VPMULHW m256 ymm ymm 23666// Construct and append a VPMULHW instruction to the active function. 23667func (c *Context) VPMULHW(mxy, xy, xy1 operand.Op) { 23668 if inst, err := x86.VPMULHW(mxy, xy, xy1); err == nil { 23669 c.Instruction(inst) 23670 } else { 23671 c.adderror(err) 23672 } 23673} 23674 23675// VPMULHW: Multiply Packed Signed Word Integers and Store High Result. 23676// 23677// Forms: 23678// 23679// VPMULHW xmm xmm xmm 23680// VPMULHW m128 xmm xmm 23681// VPMULHW ymm ymm ymm 23682// VPMULHW m256 ymm ymm 23683// Construct and append a VPMULHW instruction to the active function. 23684// Operates on the global context. 23685func VPMULHW(mxy, xy, xy1 operand.Op) { ctx.VPMULHW(mxy, xy, xy1) } 23686 23687// VPMULLD: Multiply Packed Signed Doubleword Integers and Store Low Result. 23688// 23689// Forms: 23690// 23691// VPMULLD xmm xmm xmm 23692// VPMULLD m128 xmm xmm 23693// VPMULLD ymm ymm ymm 23694// VPMULLD m256 ymm ymm 23695// Construct and append a VPMULLD instruction to the active function. 23696func (c *Context) VPMULLD(mxy, xy, xy1 operand.Op) { 23697 if inst, err := x86.VPMULLD(mxy, xy, xy1); err == nil { 23698 c.Instruction(inst) 23699 } else { 23700 c.adderror(err) 23701 } 23702} 23703 23704// VPMULLD: Multiply Packed Signed Doubleword Integers and Store Low Result. 23705// 23706// Forms: 23707// 23708// VPMULLD xmm xmm xmm 23709// VPMULLD m128 xmm xmm 23710// VPMULLD ymm ymm ymm 23711// VPMULLD m256 ymm ymm 23712// Construct and append a VPMULLD instruction to the active function. 23713// Operates on the global context. 23714func VPMULLD(mxy, xy, xy1 operand.Op) { ctx.VPMULLD(mxy, xy, xy1) } 23715 23716// VPMULLW: Multiply Packed Signed Word Integers and Store Low Result. 23717// 23718// Forms: 23719// 23720// VPMULLW xmm xmm xmm 23721// VPMULLW m128 xmm xmm 23722// VPMULLW ymm ymm ymm 23723// VPMULLW m256 ymm ymm 23724// Construct and append a VPMULLW instruction to the active function. 23725func (c *Context) VPMULLW(mxy, xy, xy1 operand.Op) { 23726 if inst, err := x86.VPMULLW(mxy, xy, xy1); err == nil { 23727 c.Instruction(inst) 23728 } else { 23729 c.adderror(err) 23730 } 23731} 23732 23733// VPMULLW: Multiply Packed Signed Word Integers and Store Low Result. 23734// 23735// Forms: 23736// 23737// VPMULLW xmm xmm xmm 23738// VPMULLW m128 xmm xmm 23739// VPMULLW ymm ymm ymm 23740// VPMULLW m256 ymm ymm 23741// Construct and append a VPMULLW instruction to the active function. 23742// Operates on the global context. 23743func VPMULLW(mxy, xy, xy1 operand.Op) { ctx.VPMULLW(mxy, xy, xy1) } 23744 23745// VPMULUDQ: Multiply Packed Unsigned Doubleword Integers. 23746// 23747// Forms: 23748// 23749// VPMULUDQ xmm xmm xmm 23750// VPMULUDQ m128 xmm xmm 23751// VPMULUDQ ymm ymm ymm 23752// VPMULUDQ m256 ymm ymm 23753// Construct and append a VPMULUDQ instruction to the active function. 23754func (c *Context) VPMULUDQ(mxy, xy, xy1 operand.Op) { 23755 if inst, err := x86.VPMULUDQ(mxy, xy, xy1); err == nil { 23756 c.Instruction(inst) 23757 } else { 23758 c.adderror(err) 23759 } 23760} 23761 23762// VPMULUDQ: Multiply Packed Unsigned Doubleword Integers. 23763// 23764// Forms: 23765// 23766// VPMULUDQ xmm xmm xmm 23767// VPMULUDQ m128 xmm xmm 23768// VPMULUDQ ymm ymm ymm 23769// VPMULUDQ m256 ymm ymm 23770// Construct and append a VPMULUDQ instruction to the active function. 23771// Operates on the global context. 23772func VPMULUDQ(mxy, xy, xy1 operand.Op) { ctx.VPMULUDQ(mxy, xy, xy1) } 23773 23774// VPOR: Packed Bitwise Logical OR. 23775// 23776// Forms: 23777// 23778// VPOR xmm xmm xmm 23779// VPOR m128 xmm xmm 23780// VPOR ymm ymm ymm 23781// VPOR m256 ymm ymm 23782// Construct and append a VPOR instruction to the active function. 23783func (c *Context) VPOR(mxy, xy, xy1 operand.Op) { 23784 if inst, err := x86.VPOR(mxy, xy, xy1); err == nil { 23785 c.Instruction(inst) 23786 } else { 23787 c.adderror(err) 23788 } 23789} 23790 23791// VPOR: Packed Bitwise Logical OR. 23792// 23793// Forms: 23794// 23795// VPOR xmm xmm xmm 23796// VPOR m128 xmm xmm 23797// VPOR ymm ymm ymm 23798// VPOR m256 ymm ymm 23799// Construct and append a VPOR instruction to the active function. 23800// Operates on the global context. 23801func VPOR(mxy, xy, xy1 operand.Op) { ctx.VPOR(mxy, xy, xy1) } 23802 23803// VPSADBW: Compute Sum of Absolute Differences. 23804// 23805// Forms: 23806// 23807// VPSADBW xmm xmm xmm 23808// VPSADBW m128 xmm xmm 23809// VPSADBW ymm ymm ymm 23810// VPSADBW m256 ymm ymm 23811// Construct and append a VPSADBW instruction to the active function. 23812func (c *Context) VPSADBW(mxy, xy, xy1 operand.Op) { 23813 if inst, err := x86.VPSADBW(mxy, xy, xy1); err == nil { 23814 c.Instruction(inst) 23815 } else { 23816 c.adderror(err) 23817 } 23818} 23819 23820// VPSADBW: Compute Sum of Absolute Differences. 23821// 23822// Forms: 23823// 23824// VPSADBW xmm xmm xmm 23825// VPSADBW m128 xmm xmm 23826// VPSADBW ymm ymm ymm 23827// VPSADBW m256 ymm ymm 23828// Construct and append a VPSADBW instruction to the active function. 23829// Operates on the global context. 23830func VPSADBW(mxy, xy, xy1 operand.Op) { ctx.VPSADBW(mxy, xy, xy1) } 23831 23832// VPSHUFB: Packed Shuffle Bytes. 23833// 23834// Forms: 23835// 23836// VPSHUFB xmm xmm xmm 23837// VPSHUFB m128 xmm xmm 23838// VPSHUFB ymm ymm ymm 23839// VPSHUFB m256 ymm ymm 23840// Construct and append a VPSHUFB instruction to the active function. 23841func (c *Context) VPSHUFB(mxy, xy, xy1 operand.Op) { 23842 if inst, err := x86.VPSHUFB(mxy, xy, xy1); err == nil { 23843 c.Instruction(inst) 23844 } else { 23845 c.adderror(err) 23846 } 23847} 23848 23849// VPSHUFB: Packed Shuffle Bytes. 23850// 23851// Forms: 23852// 23853// VPSHUFB xmm xmm xmm 23854// VPSHUFB m128 xmm xmm 23855// VPSHUFB ymm ymm ymm 23856// VPSHUFB m256 ymm ymm 23857// Construct and append a VPSHUFB instruction to the active function. 23858// Operates on the global context. 23859func VPSHUFB(mxy, xy, xy1 operand.Op) { ctx.VPSHUFB(mxy, xy, xy1) } 23860 23861// VPSHUFD: Shuffle Packed Doublewords. 23862// 23863// Forms: 23864// 23865// VPSHUFD imm8 xmm xmm 23866// VPSHUFD imm8 m128 xmm 23867// VPSHUFD imm8 ymm ymm 23868// VPSHUFD imm8 m256 ymm 23869// Construct and append a VPSHUFD instruction to the active function. 23870func (c *Context) VPSHUFD(i, mxy, xy operand.Op) { 23871 if inst, err := x86.VPSHUFD(i, mxy, xy); err == nil { 23872 c.Instruction(inst) 23873 } else { 23874 c.adderror(err) 23875 } 23876} 23877 23878// VPSHUFD: Shuffle Packed Doublewords. 23879// 23880// Forms: 23881// 23882// VPSHUFD imm8 xmm xmm 23883// VPSHUFD imm8 m128 xmm 23884// VPSHUFD imm8 ymm ymm 23885// VPSHUFD imm8 m256 ymm 23886// Construct and append a VPSHUFD instruction to the active function. 23887// Operates on the global context. 23888func VPSHUFD(i, mxy, xy operand.Op) { ctx.VPSHUFD(i, mxy, xy) } 23889 23890// VPSHUFHW: Shuffle Packed High Words. 23891// 23892// Forms: 23893// 23894// VPSHUFHW imm8 xmm xmm 23895// VPSHUFHW imm8 m128 xmm 23896// VPSHUFHW imm8 ymm ymm 23897// VPSHUFHW imm8 m256 ymm 23898// Construct and append a VPSHUFHW instruction to the active function. 23899func (c *Context) VPSHUFHW(i, mxy, xy operand.Op) { 23900 if inst, err := x86.VPSHUFHW(i, mxy, xy); err == nil { 23901 c.Instruction(inst) 23902 } else { 23903 c.adderror(err) 23904 } 23905} 23906 23907// VPSHUFHW: Shuffle Packed High Words. 23908// 23909// Forms: 23910// 23911// VPSHUFHW imm8 xmm xmm 23912// VPSHUFHW imm8 m128 xmm 23913// VPSHUFHW imm8 ymm ymm 23914// VPSHUFHW imm8 m256 ymm 23915// Construct and append a VPSHUFHW instruction to the active function. 23916// Operates on the global context. 23917func VPSHUFHW(i, mxy, xy operand.Op) { ctx.VPSHUFHW(i, mxy, xy) } 23918 23919// VPSHUFLW: Shuffle Packed Low Words. 23920// 23921// Forms: 23922// 23923// VPSHUFLW imm8 xmm xmm 23924// VPSHUFLW imm8 m128 xmm 23925// VPSHUFLW imm8 ymm ymm 23926// VPSHUFLW imm8 m256 ymm 23927// Construct and append a VPSHUFLW instruction to the active function. 23928func (c *Context) VPSHUFLW(i, mxy, xy operand.Op) { 23929 if inst, err := x86.VPSHUFLW(i, mxy, xy); err == nil { 23930 c.Instruction(inst) 23931 } else { 23932 c.adderror(err) 23933 } 23934} 23935 23936// VPSHUFLW: Shuffle Packed Low Words. 23937// 23938// Forms: 23939// 23940// VPSHUFLW imm8 xmm xmm 23941// VPSHUFLW imm8 m128 xmm 23942// VPSHUFLW imm8 ymm ymm 23943// VPSHUFLW imm8 m256 ymm 23944// Construct and append a VPSHUFLW instruction to the active function. 23945// Operates on the global context. 23946func VPSHUFLW(i, mxy, xy operand.Op) { ctx.VPSHUFLW(i, mxy, xy) } 23947 23948// VPSIGNB: Packed Sign of Byte Integers. 23949// 23950// Forms: 23951// 23952// VPSIGNB xmm xmm xmm 23953// VPSIGNB m128 xmm xmm 23954// VPSIGNB ymm ymm ymm 23955// VPSIGNB m256 ymm ymm 23956// Construct and append a VPSIGNB instruction to the active function. 23957func (c *Context) VPSIGNB(mxy, xy, xy1 operand.Op) { 23958 if inst, err := x86.VPSIGNB(mxy, xy, xy1); err == nil { 23959 c.Instruction(inst) 23960 } else { 23961 c.adderror(err) 23962 } 23963} 23964 23965// VPSIGNB: Packed Sign of Byte Integers. 23966// 23967// Forms: 23968// 23969// VPSIGNB xmm xmm xmm 23970// VPSIGNB m128 xmm xmm 23971// VPSIGNB ymm ymm ymm 23972// VPSIGNB m256 ymm ymm 23973// Construct and append a VPSIGNB instruction to the active function. 23974// Operates on the global context. 23975func VPSIGNB(mxy, xy, xy1 operand.Op) { ctx.VPSIGNB(mxy, xy, xy1) } 23976 23977// VPSIGND: Packed Sign of Doubleword Integers. 23978// 23979// Forms: 23980// 23981// VPSIGND xmm xmm xmm 23982// VPSIGND m128 xmm xmm 23983// VPSIGND ymm ymm ymm 23984// VPSIGND m256 ymm ymm 23985// Construct and append a VPSIGND instruction to the active function. 23986func (c *Context) VPSIGND(mxy, xy, xy1 operand.Op) { 23987 if inst, err := x86.VPSIGND(mxy, xy, xy1); err == nil { 23988 c.Instruction(inst) 23989 } else { 23990 c.adderror(err) 23991 } 23992} 23993 23994// VPSIGND: Packed Sign of Doubleword Integers. 23995// 23996// Forms: 23997// 23998// VPSIGND xmm xmm xmm 23999// VPSIGND m128 xmm xmm 24000// VPSIGND ymm ymm ymm 24001// VPSIGND m256 ymm ymm 24002// Construct and append a VPSIGND instruction to the active function. 24003// Operates on the global context. 24004func VPSIGND(mxy, xy, xy1 operand.Op) { ctx.VPSIGND(mxy, xy, xy1) } 24005 24006// VPSIGNW: Packed Sign of Word Integers. 24007// 24008// Forms: 24009// 24010// VPSIGNW xmm xmm xmm 24011// VPSIGNW m128 xmm xmm 24012// VPSIGNW ymm ymm ymm 24013// VPSIGNW m256 ymm ymm 24014// Construct and append a VPSIGNW instruction to the active function. 24015func (c *Context) VPSIGNW(mxy, xy, xy1 operand.Op) { 24016 if inst, err := x86.VPSIGNW(mxy, xy, xy1); err == nil { 24017 c.Instruction(inst) 24018 } else { 24019 c.adderror(err) 24020 } 24021} 24022 24023// VPSIGNW: Packed Sign of Word Integers. 24024// 24025// Forms: 24026// 24027// VPSIGNW xmm xmm xmm 24028// VPSIGNW m128 xmm xmm 24029// VPSIGNW ymm ymm ymm 24030// VPSIGNW m256 ymm ymm 24031// Construct and append a VPSIGNW instruction to the active function. 24032// Operates on the global context. 24033func VPSIGNW(mxy, xy, xy1 operand.Op) { ctx.VPSIGNW(mxy, xy, xy1) } 24034 24035// VPSLLD: Shift Packed Doubleword Data Left Logical. 24036// 24037// Forms: 24038// 24039// VPSLLD imm8 xmm xmm 24040// VPSLLD xmm xmm xmm 24041// VPSLLD m128 xmm xmm 24042// VPSLLD imm8 ymm ymm 24043// VPSLLD xmm ymm ymm 24044// VPSLLD m128 ymm ymm 24045// Construct and append a VPSLLD instruction to the active function. 24046func (c *Context) VPSLLD(imx, xy, xy1 operand.Op) { 24047 if inst, err := x86.VPSLLD(imx, xy, xy1); err == nil { 24048 c.Instruction(inst) 24049 } else { 24050 c.adderror(err) 24051 } 24052} 24053 24054// VPSLLD: Shift Packed Doubleword Data Left Logical. 24055// 24056// Forms: 24057// 24058// VPSLLD imm8 xmm xmm 24059// VPSLLD xmm xmm xmm 24060// VPSLLD m128 xmm xmm 24061// VPSLLD imm8 ymm ymm 24062// VPSLLD xmm ymm ymm 24063// VPSLLD m128 ymm ymm 24064// Construct and append a VPSLLD instruction to the active function. 24065// Operates on the global context. 24066func VPSLLD(imx, xy, xy1 operand.Op) { ctx.VPSLLD(imx, xy, xy1) } 24067 24068// VPSLLDQ: Shift Packed Double Quadword Left Logical. 24069// 24070// Forms: 24071// 24072// VPSLLDQ imm8 xmm xmm 24073// VPSLLDQ imm8 ymm ymm 24074// Construct and append a VPSLLDQ instruction to the active function. 24075func (c *Context) VPSLLDQ(i, xy, xy1 operand.Op) { 24076 if inst, err := x86.VPSLLDQ(i, xy, xy1); err == nil { 24077 c.Instruction(inst) 24078 } else { 24079 c.adderror(err) 24080 } 24081} 24082 24083// VPSLLDQ: Shift Packed Double Quadword Left Logical. 24084// 24085// Forms: 24086// 24087// VPSLLDQ imm8 xmm xmm 24088// VPSLLDQ imm8 ymm ymm 24089// Construct and append a VPSLLDQ instruction to the active function. 24090// Operates on the global context. 24091func VPSLLDQ(i, xy, xy1 operand.Op) { ctx.VPSLLDQ(i, xy, xy1) } 24092 24093// VPSLLQ: Shift Packed Quadword Data Left Logical. 24094// 24095// Forms: 24096// 24097// VPSLLQ imm8 xmm xmm 24098// VPSLLQ xmm xmm xmm 24099// VPSLLQ m128 xmm xmm 24100// VPSLLQ imm8 ymm ymm 24101// VPSLLQ xmm ymm ymm 24102// VPSLLQ m128 ymm ymm 24103// Construct and append a VPSLLQ instruction to the active function. 24104func (c *Context) VPSLLQ(imx, xy, xy1 operand.Op) { 24105 if inst, err := x86.VPSLLQ(imx, xy, xy1); err == nil { 24106 c.Instruction(inst) 24107 } else { 24108 c.adderror(err) 24109 } 24110} 24111 24112// VPSLLQ: Shift Packed Quadword Data Left Logical. 24113// 24114// Forms: 24115// 24116// VPSLLQ imm8 xmm xmm 24117// VPSLLQ xmm xmm xmm 24118// VPSLLQ m128 xmm xmm 24119// VPSLLQ imm8 ymm ymm 24120// VPSLLQ xmm ymm ymm 24121// VPSLLQ m128 ymm ymm 24122// Construct and append a VPSLLQ instruction to the active function. 24123// Operates on the global context. 24124func VPSLLQ(imx, xy, xy1 operand.Op) { ctx.VPSLLQ(imx, xy, xy1) } 24125 24126// VPSLLVD: Variable Shift Packed Doubleword Data Left Logical. 24127// 24128// Forms: 24129// 24130// VPSLLVD xmm xmm xmm 24131// VPSLLVD m128 xmm xmm 24132// VPSLLVD ymm ymm ymm 24133// VPSLLVD m256 ymm ymm 24134// Construct and append a VPSLLVD instruction to the active function. 24135func (c *Context) VPSLLVD(mxy, xy, xy1 operand.Op) { 24136 if inst, err := x86.VPSLLVD(mxy, xy, xy1); err == nil { 24137 c.Instruction(inst) 24138 } else { 24139 c.adderror(err) 24140 } 24141} 24142 24143// VPSLLVD: Variable Shift Packed Doubleword Data Left Logical. 24144// 24145// Forms: 24146// 24147// VPSLLVD xmm xmm xmm 24148// VPSLLVD m128 xmm xmm 24149// VPSLLVD ymm ymm ymm 24150// VPSLLVD m256 ymm ymm 24151// Construct and append a VPSLLVD instruction to the active function. 24152// Operates on the global context. 24153func VPSLLVD(mxy, xy, xy1 operand.Op) { ctx.VPSLLVD(mxy, xy, xy1) } 24154 24155// VPSLLVQ: Variable Shift Packed Quadword Data Left Logical. 24156// 24157// Forms: 24158// 24159// VPSLLVQ xmm xmm xmm 24160// VPSLLVQ m128 xmm xmm 24161// VPSLLVQ ymm ymm ymm 24162// VPSLLVQ m256 ymm ymm 24163// Construct and append a VPSLLVQ instruction to the active function. 24164func (c *Context) VPSLLVQ(mxy, xy, xy1 operand.Op) { 24165 if inst, err := x86.VPSLLVQ(mxy, xy, xy1); err == nil { 24166 c.Instruction(inst) 24167 } else { 24168 c.adderror(err) 24169 } 24170} 24171 24172// VPSLLVQ: Variable Shift Packed Quadword Data Left Logical. 24173// 24174// Forms: 24175// 24176// VPSLLVQ xmm xmm xmm 24177// VPSLLVQ m128 xmm xmm 24178// VPSLLVQ ymm ymm ymm 24179// VPSLLVQ m256 ymm ymm 24180// Construct and append a VPSLLVQ instruction to the active function. 24181// Operates on the global context. 24182func VPSLLVQ(mxy, xy, xy1 operand.Op) { ctx.VPSLLVQ(mxy, xy, xy1) } 24183 24184// VPSLLW: Shift Packed Word Data Left Logical. 24185// 24186// Forms: 24187// 24188// VPSLLW imm8 xmm xmm 24189// VPSLLW xmm xmm xmm 24190// VPSLLW m128 xmm xmm 24191// VPSLLW imm8 ymm ymm 24192// VPSLLW xmm ymm ymm 24193// VPSLLW m128 ymm ymm 24194// Construct and append a VPSLLW instruction to the active function. 24195func (c *Context) VPSLLW(imx, xy, xy1 operand.Op) { 24196 if inst, err := x86.VPSLLW(imx, xy, xy1); err == nil { 24197 c.Instruction(inst) 24198 } else { 24199 c.adderror(err) 24200 } 24201} 24202 24203// VPSLLW: Shift Packed Word Data Left Logical. 24204// 24205// Forms: 24206// 24207// VPSLLW imm8 xmm xmm 24208// VPSLLW xmm xmm xmm 24209// VPSLLW m128 xmm xmm 24210// VPSLLW imm8 ymm ymm 24211// VPSLLW xmm ymm ymm 24212// VPSLLW m128 ymm ymm 24213// Construct and append a VPSLLW instruction to the active function. 24214// Operates on the global context. 24215func VPSLLW(imx, xy, xy1 operand.Op) { ctx.VPSLLW(imx, xy, xy1) } 24216 24217// VPSRAD: Shift Packed Doubleword Data Right Arithmetic. 24218// 24219// Forms: 24220// 24221// VPSRAD imm8 xmm xmm 24222// VPSRAD xmm xmm xmm 24223// VPSRAD m128 xmm xmm 24224// VPSRAD imm8 ymm ymm 24225// VPSRAD xmm ymm ymm 24226// VPSRAD m128 ymm ymm 24227// Construct and append a VPSRAD instruction to the active function. 24228func (c *Context) VPSRAD(imx, xy, xy1 operand.Op) { 24229 if inst, err := x86.VPSRAD(imx, xy, xy1); err == nil { 24230 c.Instruction(inst) 24231 } else { 24232 c.adderror(err) 24233 } 24234} 24235 24236// VPSRAD: Shift Packed Doubleword Data Right Arithmetic. 24237// 24238// Forms: 24239// 24240// VPSRAD imm8 xmm xmm 24241// VPSRAD xmm xmm xmm 24242// VPSRAD m128 xmm xmm 24243// VPSRAD imm8 ymm ymm 24244// VPSRAD xmm ymm ymm 24245// VPSRAD m128 ymm ymm 24246// Construct and append a VPSRAD instruction to the active function. 24247// Operates on the global context. 24248func VPSRAD(imx, xy, xy1 operand.Op) { ctx.VPSRAD(imx, xy, xy1) } 24249 24250// VPSRAVD: Variable Shift Packed Doubleword Data Right Arithmetic. 24251// 24252// Forms: 24253// 24254// VPSRAVD xmm xmm xmm 24255// VPSRAVD m128 xmm xmm 24256// VPSRAVD ymm ymm ymm 24257// VPSRAVD m256 ymm ymm 24258// Construct and append a VPSRAVD instruction to the active function. 24259func (c *Context) VPSRAVD(mxy, xy, xy1 operand.Op) { 24260 if inst, err := x86.VPSRAVD(mxy, xy, xy1); err == nil { 24261 c.Instruction(inst) 24262 } else { 24263 c.adderror(err) 24264 } 24265} 24266 24267// VPSRAVD: Variable Shift Packed Doubleword Data Right Arithmetic. 24268// 24269// Forms: 24270// 24271// VPSRAVD xmm xmm xmm 24272// VPSRAVD m128 xmm xmm 24273// VPSRAVD ymm ymm ymm 24274// VPSRAVD m256 ymm ymm 24275// Construct and append a VPSRAVD instruction to the active function. 24276// Operates on the global context. 24277func VPSRAVD(mxy, xy, xy1 operand.Op) { ctx.VPSRAVD(mxy, xy, xy1) } 24278 24279// VPSRAW: Shift Packed Word Data Right Arithmetic. 24280// 24281// Forms: 24282// 24283// VPSRAW imm8 xmm xmm 24284// VPSRAW xmm xmm xmm 24285// VPSRAW m128 xmm xmm 24286// VPSRAW imm8 ymm ymm 24287// VPSRAW xmm ymm ymm 24288// VPSRAW m128 ymm ymm 24289// Construct and append a VPSRAW instruction to the active function. 24290func (c *Context) VPSRAW(imx, xy, xy1 operand.Op) { 24291 if inst, err := x86.VPSRAW(imx, xy, xy1); err == nil { 24292 c.Instruction(inst) 24293 } else { 24294 c.adderror(err) 24295 } 24296} 24297 24298// VPSRAW: Shift Packed Word Data Right Arithmetic. 24299// 24300// Forms: 24301// 24302// VPSRAW imm8 xmm xmm 24303// VPSRAW xmm xmm xmm 24304// VPSRAW m128 xmm xmm 24305// VPSRAW imm8 ymm ymm 24306// VPSRAW xmm ymm ymm 24307// VPSRAW m128 ymm ymm 24308// Construct and append a VPSRAW instruction to the active function. 24309// Operates on the global context. 24310func VPSRAW(imx, xy, xy1 operand.Op) { ctx.VPSRAW(imx, xy, xy1) } 24311 24312// VPSRLD: Shift Packed Doubleword Data Right Logical. 24313// 24314// Forms: 24315// 24316// VPSRLD imm8 xmm xmm 24317// VPSRLD xmm xmm xmm 24318// VPSRLD m128 xmm xmm 24319// VPSRLD imm8 ymm ymm 24320// VPSRLD xmm ymm ymm 24321// VPSRLD m128 ymm ymm 24322// Construct and append a VPSRLD instruction to the active function. 24323func (c *Context) VPSRLD(imx, xy, xy1 operand.Op) { 24324 if inst, err := x86.VPSRLD(imx, xy, xy1); err == nil { 24325 c.Instruction(inst) 24326 } else { 24327 c.adderror(err) 24328 } 24329} 24330 24331// VPSRLD: Shift Packed Doubleword Data Right Logical. 24332// 24333// Forms: 24334// 24335// VPSRLD imm8 xmm xmm 24336// VPSRLD xmm xmm xmm 24337// VPSRLD m128 xmm xmm 24338// VPSRLD imm8 ymm ymm 24339// VPSRLD xmm ymm ymm 24340// VPSRLD m128 ymm ymm 24341// Construct and append a VPSRLD instruction to the active function. 24342// Operates on the global context. 24343func VPSRLD(imx, xy, xy1 operand.Op) { ctx.VPSRLD(imx, xy, xy1) } 24344 24345// VPSRLDQ: Shift Packed Double Quadword Right Logical. 24346// 24347// Forms: 24348// 24349// VPSRLDQ imm8 xmm xmm 24350// VPSRLDQ imm8 ymm ymm 24351// Construct and append a VPSRLDQ instruction to the active function. 24352func (c *Context) VPSRLDQ(i, xy, xy1 operand.Op) { 24353 if inst, err := x86.VPSRLDQ(i, xy, xy1); err == nil { 24354 c.Instruction(inst) 24355 } else { 24356 c.adderror(err) 24357 } 24358} 24359 24360// VPSRLDQ: Shift Packed Double Quadword Right Logical. 24361// 24362// Forms: 24363// 24364// VPSRLDQ imm8 xmm xmm 24365// VPSRLDQ imm8 ymm ymm 24366// Construct and append a VPSRLDQ instruction to the active function. 24367// Operates on the global context. 24368func VPSRLDQ(i, xy, xy1 operand.Op) { ctx.VPSRLDQ(i, xy, xy1) } 24369 24370// VPSRLQ: Shift Packed Quadword Data Right Logical. 24371// 24372// Forms: 24373// 24374// VPSRLQ imm8 xmm xmm 24375// VPSRLQ xmm xmm xmm 24376// VPSRLQ m128 xmm xmm 24377// VPSRLQ imm8 ymm ymm 24378// VPSRLQ xmm ymm ymm 24379// VPSRLQ m128 ymm ymm 24380// Construct and append a VPSRLQ instruction to the active function. 24381func (c *Context) VPSRLQ(imx, xy, xy1 operand.Op) { 24382 if inst, err := x86.VPSRLQ(imx, xy, xy1); err == nil { 24383 c.Instruction(inst) 24384 } else { 24385 c.adderror(err) 24386 } 24387} 24388 24389// VPSRLQ: Shift Packed Quadword Data Right Logical. 24390// 24391// Forms: 24392// 24393// VPSRLQ imm8 xmm xmm 24394// VPSRLQ xmm xmm xmm 24395// VPSRLQ m128 xmm xmm 24396// VPSRLQ imm8 ymm ymm 24397// VPSRLQ xmm ymm ymm 24398// VPSRLQ m128 ymm ymm 24399// Construct and append a VPSRLQ instruction to the active function. 24400// Operates on the global context. 24401func VPSRLQ(imx, xy, xy1 operand.Op) { ctx.VPSRLQ(imx, xy, xy1) } 24402 24403// VPSRLVD: Variable Shift Packed Doubleword Data Right Logical. 24404// 24405// Forms: 24406// 24407// VPSRLVD xmm xmm xmm 24408// VPSRLVD m128 xmm xmm 24409// VPSRLVD ymm ymm ymm 24410// VPSRLVD m256 ymm ymm 24411// Construct and append a VPSRLVD instruction to the active function. 24412func (c *Context) VPSRLVD(mxy, xy, xy1 operand.Op) { 24413 if inst, err := x86.VPSRLVD(mxy, xy, xy1); err == nil { 24414 c.Instruction(inst) 24415 } else { 24416 c.adderror(err) 24417 } 24418} 24419 24420// VPSRLVD: Variable Shift Packed Doubleword Data Right Logical. 24421// 24422// Forms: 24423// 24424// VPSRLVD xmm xmm xmm 24425// VPSRLVD m128 xmm xmm 24426// VPSRLVD ymm ymm ymm 24427// VPSRLVD m256 ymm ymm 24428// Construct and append a VPSRLVD instruction to the active function. 24429// Operates on the global context. 24430func VPSRLVD(mxy, xy, xy1 operand.Op) { ctx.VPSRLVD(mxy, xy, xy1) } 24431 24432// VPSRLVQ: Variable Shift Packed Quadword Data Right Logical. 24433// 24434// Forms: 24435// 24436// VPSRLVQ xmm xmm xmm 24437// VPSRLVQ m128 xmm xmm 24438// VPSRLVQ ymm ymm ymm 24439// VPSRLVQ m256 ymm ymm 24440// Construct and append a VPSRLVQ instruction to the active function. 24441func (c *Context) VPSRLVQ(mxy, xy, xy1 operand.Op) { 24442 if inst, err := x86.VPSRLVQ(mxy, xy, xy1); err == nil { 24443 c.Instruction(inst) 24444 } else { 24445 c.adderror(err) 24446 } 24447} 24448 24449// VPSRLVQ: Variable Shift Packed Quadword Data Right Logical. 24450// 24451// Forms: 24452// 24453// VPSRLVQ xmm xmm xmm 24454// VPSRLVQ m128 xmm xmm 24455// VPSRLVQ ymm ymm ymm 24456// VPSRLVQ m256 ymm ymm 24457// Construct and append a VPSRLVQ instruction to the active function. 24458// Operates on the global context. 24459func VPSRLVQ(mxy, xy, xy1 operand.Op) { ctx.VPSRLVQ(mxy, xy, xy1) } 24460 24461// VPSRLW: Shift Packed Word Data Right Logical. 24462// 24463// Forms: 24464// 24465// VPSRLW imm8 xmm xmm 24466// VPSRLW xmm xmm xmm 24467// VPSRLW m128 xmm xmm 24468// VPSRLW imm8 ymm ymm 24469// VPSRLW xmm ymm ymm 24470// VPSRLW m128 ymm ymm 24471// Construct and append a VPSRLW instruction to the active function. 24472func (c *Context) VPSRLW(imx, xy, xy1 operand.Op) { 24473 if inst, err := x86.VPSRLW(imx, xy, xy1); err == nil { 24474 c.Instruction(inst) 24475 } else { 24476 c.adderror(err) 24477 } 24478} 24479 24480// VPSRLW: Shift Packed Word Data Right Logical. 24481// 24482// Forms: 24483// 24484// VPSRLW imm8 xmm xmm 24485// VPSRLW xmm xmm xmm 24486// VPSRLW m128 xmm xmm 24487// VPSRLW imm8 ymm ymm 24488// VPSRLW xmm ymm ymm 24489// VPSRLW m128 ymm ymm 24490// Construct and append a VPSRLW instruction to the active function. 24491// Operates on the global context. 24492func VPSRLW(imx, xy, xy1 operand.Op) { ctx.VPSRLW(imx, xy, xy1) } 24493 24494// VPSUBB: Subtract Packed Byte Integers. 24495// 24496// Forms: 24497// 24498// VPSUBB xmm xmm xmm 24499// VPSUBB m128 xmm xmm 24500// VPSUBB ymm ymm ymm 24501// VPSUBB m256 ymm ymm 24502// Construct and append a VPSUBB instruction to the active function. 24503func (c *Context) VPSUBB(mxy, xy, xy1 operand.Op) { 24504 if inst, err := x86.VPSUBB(mxy, xy, xy1); err == nil { 24505 c.Instruction(inst) 24506 } else { 24507 c.adderror(err) 24508 } 24509} 24510 24511// VPSUBB: Subtract Packed Byte Integers. 24512// 24513// Forms: 24514// 24515// VPSUBB xmm xmm xmm 24516// VPSUBB m128 xmm xmm 24517// VPSUBB ymm ymm ymm 24518// VPSUBB m256 ymm ymm 24519// Construct and append a VPSUBB instruction to the active function. 24520// Operates on the global context. 24521func VPSUBB(mxy, xy, xy1 operand.Op) { ctx.VPSUBB(mxy, xy, xy1) } 24522 24523// VPSUBD: Subtract Packed Doubleword Integers. 24524// 24525// Forms: 24526// 24527// VPSUBD xmm xmm xmm 24528// VPSUBD m128 xmm xmm 24529// VPSUBD ymm ymm ymm 24530// VPSUBD m256 ymm ymm 24531// Construct and append a VPSUBD instruction to the active function. 24532func (c *Context) VPSUBD(mxy, xy, xy1 operand.Op) { 24533 if inst, err := x86.VPSUBD(mxy, xy, xy1); err == nil { 24534 c.Instruction(inst) 24535 } else { 24536 c.adderror(err) 24537 } 24538} 24539 24540// VPSUBD: Subtract Packed Doubleword Integers. 24541// 24542// Forms: 24543// 24544// VPSUBD xmm xmm xmm 24545// VPSUBD m128 xmm xmm 24546// VPSUBD ymm ymm ymm 24547// VPSUBD m256 ymm ymm 24548// Construct and append a VPSUBD instruction to the active function. 24549// Operates on the global context. 24550func VPSUBD(mxy, xy, xy1 operand.Op) { ctx.VPSUBD(mxy, xy, xy1) } 24551 24552// VPSUBQ: Subtract Packed Quadword Integers. 24553// 24554// Forms: 24555// 24556// VPSUBQ xmm xmm xmm 24557// VPSUBQ m128 xmm xmm 24558// VPSUBQ ymm ymm ymm 24559// VPSUBQ m256 ymm ymm 24560// Construct and append a VPSUBQ instruction to the active function. 24561func (c *Context) VPSUBQ(mxy, xy, xy1 operand.Op) { 24562 if inst, err := x86.VPSUBQ(mxy, xy, xy1); err == nil { 24563 c.Instruction(inst) 24564 } else { 24565 c.adderror(err) 24566 } 24567} 24568 24569// VPSUBQ: Subtract Packed Quadword Integers. 24570// 24571// Forms: 24572// 24573// VPSUBQ xmm xmm xmm 24574// VPSUBQ m128 xmm xmm 24575// VPSUBQ ymm ymm ymm 24576// VPSUBQ m256 ymm ymm 24577// Construct and append a VPSUBQ instruction to the active function. 24578// Operates on the global context. 24579func VPSUBQ(mxy, xy, xy1 operand.Op) { ctx.VPSUBQ(mxy, xy, xy1) } 24580 24581// VPSUBSB: Subtract Packed Signed Byte Integers with Signed Saturation. 24582// 24583// Forms: 24584// 24585// VPSUBSB xmm xmm xmm 24586// VPSUBSB m128 xmm xmm 24587// VPSUBSB ymm ymm ymm 24588// VPSUBSB m256 ymm ymm 24589// Construct and append a VPSUBSB instruction to the active function. 24590func (c *Context) VPSUBSB(mxy, xy, xy1 operand.Op) { 24591 if inst, err := x86.VPSUBSB(mxy, xy, xy1); err == nil { 24592 c.Instruction(inst) 24593 } else { 24594 c.adderror(err) 24595 } 24596} 24597 24598// VPSUBSB: Subtract Packed Signed Byte Integers with Signed Saturation. 24599// 24600// Forms: 24601// 24602// VPSUBSB xmm xmm xmm 24603// VPSUBSB m128 xmm xmm 24604// VPSUBSB ymm ymm ymm 24605// VPSUBSB m256 ymm ymm 24606// Construct and append a VPSUBSB instruction to the active function. 24607// Operates on the global context. 24608func VPSUBSB(mxy, xy, xy1 operand.Op) { ctx.VPSUBSB(mxy, xy, xy1) } 24609 24610// VPSUBSW: Subtract Packed Signed Word Integers with Signed Saturation. 24611// 24612// Forms: 24613// 24614// VPSUBSW xmm xmm xmm 24615// VPSUBSW m128 xmm xmm 24616// VPSUBSW ymm ymm ymm 24617// VPSUBSW m256 ymm ymm 24618// Construct and append a VPSUBSW instruction to the active function. 24619func (c *Context) VPSUBSW(mxy, xy, xy1 operand.Op) { 24620 if inst, err := x86.VPSUBSW(mxy, xy, xy1); err == nil { 24621 c.Instruction(inst) 24622 } else { 24623 c.adderror(err) 24624 } 24625} 24626 24627// VPSUBSW: Subtract Packed Signed Word Integers with Signed Saturation. 24628// 24629// Forms: 24630// 24631// VPSUBSW xmm xmm xmm 24632// VPSUBSW m128 xmm xmm 24633// VPSUBSW ymm ymm ymm 24634// VPSUBSW m256 ymm ymm 24635// Construct and append a VPSUBSW instruction to the active function. 24636// Operates on the global context. 24637func VPSUBSW(mxy, xy, xy1 operand.Op) { ctx.VPSUBSW(mxy, xy, xy1) } 24638 24639// VPSUBUSB: Subtract Packed Unsigned Byte Integers with Unsigned Saturation. 24640// 24641// Forms: 24642// 24643// VPSUBUSB xmm xmm xmm 24644// VPSUBUSB m128 xmm xmm 24645// VPSUBUSB ymm ymm ymm 24646// VPSUBUSB m256 ymm ymm 24647// Construct and append a VPSUBUSB instruction to the active function. 24648func (c *Context) VPSUBUSB(mxy, xy, xy1 operand.Op) { 24649 if inst, err := x86.VPSUBUSB(mxy, xy, xy1); err == nil { 24650 c.Instruction(inst) 24651 } else { 24652 c.adderror(err) 24653 } 24654} 24655 24656// VPSUBUSB: Subtract Packed Unsigned Byte Integers with Unsigned Saturation. 24657// 24658// Forms: 24659// 24660// VPSUBUSB xmm xmm xmm 24661// VPSUBUSB m128 xmm xmm 24662// VPSUBUSB ymm ymm ymm 24663// VPSUBUSB m256 ymm ymm 24664// Construct and append a VPSUBUSB instruction to the active function. 24665// Operates on the global context. 24666func VPSUBUSB(mxy, xy, xy1 operand.Op) { ctx.VPSUBUSB(mxy, xy, xy1) } 24667 24668// VPSUBUSW: Subtract Packed Unsigned Word Integers with Unsigned Saturation. 24669// 24670// Forms: 24671// 24672// VPSUBUSW xmm xmm xmm 24673// VPSUBUSW m128 xmm xmm 24674// VPSUBUSW ymm ymm ymm 24675// VPSUBUSW m256 ymm ymm 24676// Construct and append a VPSUBUSW instruction to the active function. 24677func (c *Context) VPSUBUSW(mxy, xy, xy1 operand.Op) { 24678 if inst, err := x86.VPSUBUSW(mxy, xy, xy1); err == nil { 24679 c.Instruction(inst) 24680 } else { 24681 c.adderror(err) 24682 } 24683} 24684 24685// VPSUBUSW: Subtract Packed Unsigned Word Integers with Unsigned Saturation. 24686// 24687// Forms: 24688// 24689// VPSUBUSW xmm xmm xmm 24690// VPSUBUSW m128 xmm xmm 24691// VPSUBUSW ymm ymm ymm 24692// VPSUBUSW m256 ymm ymm 24693// Construct and append a VPSUBUSW instruction to the active function. 24694// Operates on the global context. 24695func VPSUBUSW(mxy, xy, xy1 operand.Op) { ctx.VPSUBUSW(mxy, xy, xy1) } 24696 24697// VPSUBW: Subtract Packed Word Integers. 24698// 24699// Forms: 24700// 24701// VPSUBW xmm xmm xmm 24702// VPSUBW m128 xmm xmm 24703// VPSUBW ymm ymm ymm 24704// VPSUBW m256 ymm ymm 24705// Construct and append a VPSUBW instruction to the active function. 24706func (c *Context) VPSUBW(mxy, xy, xy1 operand.Op) { 24707 if inst, err := x86.VPSUBW(mxy, xy, xy1); err == nil { 24708 c.Instruction(inst) 24709 } else { 24710 c.adderror(err) 24711 } 24712} 24713 24714// VPSUBW: Subtract Packed Word Integers. 24715// 24716// Forms: 24717// 24718// VPSUBW xmm xmm xmm 24719// VPSUBW m128 xmm xmm 24720// VPSUBW ymm ymm ymm 24721// VPSUBW m256 ymm ymm 24722// Construct and append a VPSUBW instruction to the active function. 24723// Operates on the global context. 24724func VPSUBW(mxy, xy, xy1 operand.Op) { ctx.VPSUBW(mxy, xy, xy1) } 24725 24726// VPTEST: Packed Logical Compare. 24727// 24728// Forms: 24729// 24730// VPTEST xmm xmm 24731// VPTEST m128 xmm 24732// VPTEST ymm ymm 24733// VPTEST m256 ymm 24734// Construct and append a VPTEST instruction to the active function. 24735func (c *Context) VPTEST(mxy, xy operand.Op) { 24736 if inst, err := x86.VPTEST(mxy, xy); err == nil { 24737 c.Instruction(inst) 24738 } else { 24739 c.adderror(err) 24740 } 24741} 24742 24743// VPTEST: Packed Logical Compare. 24744// 24745// Forms: 24746// 24747// VPTEST xmm xmm 24748// VPTEST m128 xmm 24749// VPTEST ymm ymm 24750// VPTEST m256 ymm 24751// Construct and append a VPTEST instruction to the active function. 24752// Operates on the global context. 24753func VPTEST(mxy, xy operand.Op) { ctx.VPTEST(mxy, xy) } 24754 24755// VPUNPCKHBW: Unpack and Interleave High-Order Bytes into Words. 24756// 24757// Forms: 24758// 24759// VPUNPCKHBW xmm xmm xmm 24760// VPUNPCKHBW m128 xmm xmm 24761// VPUNPCKHBW ymm ymm ymm 24762// VPUNPCKHBW m256 ymm ymm 24763// Construct and append a VPUNPCKHBW instruction to the active function. 24764func (c *Context) VPUNPCKHBW(mxy, xy, xy1 operand.Op) { 24765 if inst, err := x86.VPUNPCKHBW(mxy, xy, xy1); err == nil { 24766 c.Instruction(inst) 24767 } else { 24768 c.adderror(err) 24769 } 24770} 24771 24772// VPUNPCKHBW: Unpack and Interleave High-Order Bytes into Words. 24773// 24774// Forms: 24775// 24776// VPUNPCKHBW xmm xmm xmm 24777// VPUNPCKHBW m128 xmm xmm 24778// VPUNPCKHBW ymm ymm ymm 24779// VPUNPCKHBW m256 ymm ymm 24780// Construct and append a VPUNPCKHBW instruction to the active function. 24781// Operates on the global context. 24782func VPUNPCKHBW(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKHBW(mxy, xy, xy1) } 24783 24784// VPUNPCKHDQ: Unpack and Interleave High-Order Doublewords into Quadwords. 24785// 24786// Forms: 24787// 24788// VPUNPCKHDQ xmm xmm xmm 24789// VPUNPCKHDQ m128 xmm xmm 24790// VPUNPCKHDQ ymm ymm ymm 24791// VPUNPCKHDQ m256 ymm ymm 24792// Construct and append a VPUNPCKHDQ instruction to the active function. 24793func (c *Context) VPUNPCKHDQ(mxy, xy, xy1 operand.Op) { 24794 if inst, err := x86.VPUNPCKHDQ(mxy, xy, xy1); err == nil { 24795 c.Instruction(inst) 24796 } else { 24797 c.adderror(err) 24798 } 24799} 24800 24801// VPUNPCKHDQ: Unpack and Interleave High-Order Doublewords into Quadwords. 24802// 24803// Forms: 24804// 24805// VPUNPCKHDQ xmm xmm xmm 24806// VPUNPCKHDQ m128 xmm xmm 24807// VPUNPCKHDQ ymm ymm ymm 24808// VPUNPCKHDQ m256 ymm ymm 24809// Construct and append a VPUNPCKHDQ instruction to the active function. 24810// Operates on the global context. 24811func VPUNPCKHDQ(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKHDQ(mxy, xy, xy1) } 24812 24813// VPUNPCKHQDQ: Unpack and Interleave High-Order Quadwords into Double Quadwords. 24814// 24815// Forms: 24816// 24817// VPUNPCKHQDQ xmm xmm xmm 24818// VPUNPCKHQDQ m128 xmm xmm 24819// VPUNPCKHQDQ ymm ymm ymm 24820// VPUNPCKHQDQ m256 ymm ymm 24821// Construct and append a VPUNPCKHQDQ instruction to the active function. 24822func (c *Context) VPUNPCKHQDQ(mxy, xy, xy1 operand.Op) { 24823 if inst, err := x86.VPUNPCKHQDQ(mxy, xy, xy1); err == nil { 24824 c.Instruction(inst) 24825 } else { 24826 c.adderror(err) 24827 } 24828} 24829 24830// VPUNPCKHQDQ: Unpack and Interleave High-Order Quadwords into Double Quadwords. 24831// 24832// Forms: 24833// 24834// VPUNPCKHQDQ xmm xmm xmm 24835// VPUNPCKHQDQ m128 xmm xmm 24836// VPUNPCKHQDQ ymm ymm ymm 24837// VPUNPCKHQDQ m256 ymm ymm 24838// Construct and append a VPUNPCKHQDQ instruction to the active function. 24839// Operates on the global context. 24840func VPUNPCKHQDQ(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKHQDQ(mxy, xy, xy1) } 24841 24842// VPUNPCKHWD: Unpack and Interleave High-Order Words into Doublewords. 24843// 24844// Forms: 24845// 24846// VPUNPCKHWD xmm xmm xmm 24847// VPUNPCKHWD m128 xmm xmm 24848// VPUNPCKHWD ymm ymm ymm 24849// VPUNPCKHWD m256 ymm ymm 24850// Construct and append a VPUNPCKHWD instruction to the active function. 24851func (c *Context) VPUNPCKHWD(mxy, xy, xy1 operand.Op) { 24852 if inst, err := x86.VPUNPCKHWD(mxy, xy, xy1); err == nil { 24853 c.Instruction(inst) 24854 } else { 24855 c.adderror(err) 24856 } 24857} 24858 24859// VPUNPCKHWD: Unpack and Interleave High-Order Words into Doublewords. 24860// 24861// Forms: 24862// 24863// VPUNPCKHWD xmm xmm xmm 24864// VPUNPCKHWD m128 xmm xmm 24865// VPUNPCKHWD ymm ymm ymm 24866// VPUNPCKHWD m256 ymm ymm 24867// Construct and append a VPUNPCKHWD instruction to the active function. 24868// Operates on the global context. 24869func VPUNPCKHWD(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKHWD(mxy, xy, xy1) } 24870 24871// VPUNPCKLBW: Unpack and Interleave Low-Order Bytes into Words. 24872// 24873// Forms: 24874// 24875// VPUNPCKLBW xmm xmm xmm 24876// VPUNPCKLBW m128 xmm xmm 24877// VPUNPCKLBW ymm ymm ymm 24878// VPUNPCKLBW m256 ymm ymm 24879// Construct and append a VPUNPCKLBW instruction to the active function. 24880func (c *Context) VPUNPCKLBW(mxy, xy, xy1 operand.Op) { 24881 if inst, err := x86.VPUNPCKLBW(mxy, xy, xy1); err == nil { 24882 c.Instruction(inst) 24883 } else { 24884 c.adderror(err) 24885 } 24886} 24887 24888// VPUNPCKLBW: Unpack and Interleave Low-Order Bytes into Words. 24889// 24890// Forms: 24891// 24892// VPUNPCKLBW xmm xmm xmm 24893// VPUNPCKLBW m128 xmm xmm 24894// VPUNPCKLBW ymm ymm ymm 24895// VPUNPCKLBW m256 ymm ymm 24896// Construct and append a VPUNPCKLBW instruction to the active function. 24897// Operates on the global context. 24898func VPUNPCKLBW(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKLBW(mxy, xy, xy1) } 24899 24900// VPUNPCKLDQ: Unpack and Interleave Low-Order Doublewords into Quadwords. 24901// 24902// Forms: 24903// 24904// VPUNPCKLDQ xmm xmm xmm 24905// VPUNPCKLDQ m128 xmm xmm 24906// VPUNPCKLDQ ymm ymm ymm 24907// VPUNPCKLDQ m256 ymm ymm 24908// Construct and append a VPUNPCKLDQ instruction to the active function. 24909func (c *Context) VPUNPCKLDQ(mxy, xy, xy1 operand.Op) { 24910 if inst, err := x86.VPUNPCKLDQ(mxy, xy, xy1); err == nil { 24911 c.Instruction(inst) 24912 } else { 24913 c.adderror(err) 24914 } 24915} 24916 24917// VPUNPCKLDQ: Unpack and Interleave Low-Order Doublewords into Quadwords. 24918// 24919// Forms: 24920// 24921// VPUNPCKLDQ xmm xmm xmm 24922// VPUNPCKLDQ m128 xmm xmm 24923// VPUNPCKLDQ ymm ymm ymm 24924// VPUNPCKLDQ m256 ymm ymm 24925// Construct and append a VPUNPCKLDQ instruction to the active function. 24926// Operates on the global context. 24927func VPUNPCKLDQ(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKLDQ(mxy, xy, xy1) } 24928 24929// VPUNPCKLQDQ: Unpack and Interleave Low-Order Quadwords into Double Quadwords. 24930// 24931// Forms: 24932// 24933// VPUNPCKLQDQ xmm xmm xmm 24934// VPUNPCKLQDQ m128 xmm xmm 24935// VPUNPCKLQDQ ymm ymm ymm 24936// VPUNPCKLQDQ m256 ymm ymm 24937// Construct and append a VPUNPCKLQDQ instruction to the active function. 24938func (c *Context) VPUNPCKLQDQ(mxy, xy, xy1 operand.Op) { 24939 if inst, err := x86.VPUNPCKLQDQ(mxy, xy, xy1); err == nil { 24940 c.Instruction(inst) 24941 } else { 24942 c.adderror(err) 24943 } 24944} 24945 24946// VPUNPCKLQDQ: Unpack and Interleave Low-Order Quadwords into Double Quadwords. 24947// 24948// Forms: 24949// 24950// VPUNPCKLQDQ xmm xmm xmm 24951// VPUNPCKLQDQ m128 xmm xmm 24952// VPUNPCKLQDQ ymm ymm ymm 24953// VPUNPCKLQDQ m256 ymm ymm 24954// Construct and append a VPUNPCKLQDQ instruction to the active function. 24955// Operates on the global context. 24956func VPUNPCKLQDQ(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKLQDQ(mxy, xy, xy1) } 24957 24958// VPUNPCKLWD: Unpack and Interleave Low-Order Words into Doublewords. 24959// 24960// Forms: 24961// 24962// VPUNPCKLWD xmm xmm xmm 24963// VPUNPCKLWD m128 xmm xmm 24964// VPUNPCKLWD ymm ymm ymm 24965// VPUNPCKLWD m256 ymm ymm 24966// Construct and append a VPUNPCKLWD instruction to the active function. 24967func (c *Context) VPUNPCKLWD(mxy, xy, xy1 operand.Op) { 24968 if inst, err := x86.VPUNPCKLWD(mxy, xy, xy1); err == nil { 24969 c.Instruction(inst) 24970 } else { 24971 c.adderror(err) 24972 } 24973} 24974 24975// VPUNPCKLWD: Unpack and Interleave Low-Order Words into Doublewords. 24976// 24977// Forms: 24978// 24979// VPUNPCKLWD xmm xmm xmm 24980// VPUNPCKLWD m128 xmm xmm 24981// VPUNPCKLWD ymm ymm ymm 24982// VPUNPCKLWD m256 ymm ymm 24983// Construct and append a VPUNPCKLWD instruction to the active function. 24984// Operates on the global context. 24985func VPUNPCKLWD(mxy, xy, xy1 operand.Op) { ctx.VPUNPCKLWD(mxy, xy, xy1) } 24986 24987// VPXOR: Packed Bitwise Logical Exclusive OR. 24988// 24989// Forms: 24990// 24991// VPXOR xmm xmm xmm 24992// VPXOR m128 xmm xmm 24993// VPXOR ymm ymm ymm 24994// VPXOR m256 ymm ymm 24995// Construct and append a VPXOR instruction to the active function. 24996func (c *Context) VPXOR(mxy, xy, xy1 operand.Op) { 24997 if inst, err := x86.VPXOR(mxy, xy, xy1); err == nil { 24998 c.Instruction(inst) 24999 } else { 25000 c.adderror(err) 25001 } 25002} 25003 25004// VPXOR: Packed Bitwise Logical Exclusive OR. 25005// 25006// Forms: 25007// 25008// VPXOR xmm xmm xmm 25009// VPXOR m128 xmm xmm 25010// VPXOR ymm ymm ymm 25011// VPXOR m256 ymm ymm 25012// Construct and append a VPXOR instruction to the active function. 25013// Operates on the global context. 25014func VPXOR(mxy, xy, xy1 operand.Op) { ctx.VPXOR(mxy, xy, xy1) } 25015 25016// VRCPPS: Compute Approximate Reciprocals of Packed Single-Precision Floating-Point Values. 25017// 25018// Forms: 25019// 25020// VRCPPS xmm xmm 25021// VRCPPS m128 xmm 25022// VRCPPS ymm ymm 25023// VRCPPS m256 ymm 25024// Construct and append a VRCPPS instruction to the active function. 25025func (c *Context) VRCPPS(mxy, xy operand.Op) { 25026 if inst, err := x86.VRCPPS(mxy, xy); err == nil { 25027 c.Instruction(inst) 25028 } else { 25029 c.adderror(err) 25030 } 25031} 25032 25033// VRCPPS: Compute Approximate Reciprocals of Packed Single-Precision Floating-Point Values. 25034// 25035// Forms: 25036// 25037// VRCPPS xmm xmm 25038// VRCPPS m128 xmm 25039// VRCPPS ymm ymm 25040// VRCPPS m256 ymm 25041// Construct and append a VRCPPS instruction to the active function. 25042// Operates on the global context. 25043func VRCPPS(mxy, xy operand.Op) { ctx.VRCPPS(mxy, xy) } 25044 25045// VRCPSS: Compute Approximate Reciprocal of Scalar Single-Precision Floating-Point Values. 25046// 25047// Forms: 25048// 25049// VRCPSS xmm xmm xmm 25050// VRCPSS m32 xmm xmm 25051// Construct and append a VRCPSS instruction to the active function. 25052func (c *Context) VRCPSS(mx, x, x1 operand.Op) { 25053 if inst, err := x86.VRCPSS(mx, x, x1); err == nil { 25054 c.Instruction(inst) 25055 } else { 25056 c.adderror(err) 25057 } 25058} 25059 25060// VRCPSS: Compute Approximate Reciprocal of Scalar Single-Precision Floating-Point Values. 25061// 25062// Forms: 25063// 25064// VRCPSS xmm xmm xmm 25065// VRCPSS m32 xmm xmm 25066// Construct and append a VRCPSS instruction to the active function. 25067// Operates on the global context. 25068func VRCPSS(mx, x, x1 operand.Op) { ctx.VRCPSS(mx, x, x1) } 25069 25070// VROUNDPD: Round Packed Double Precision Floating-Point Values. 25071// 25072// Forms: 25073// 25074// VROUNDPD imm8 xmm xmm 25075// VROUNDPD imm8 m128 xmm 25076// VROUNDPD imm8 ymm ymm 25077// VROUNDPD imm8 m256 ymm 25078// Construct and append a VROUNDPD instruction to the active function. 25079func (c *Context) VROUNDPD(i, mxy, xy operand.Op) { 25080 if inst, err := x86.VROUNDPD(i, mxy, xy); err == nil { 25081 c.Instruction(inst) 25082 } else { 25083 c.adderror(err) 25084 } 25085} 25086 25087// VROUNDPD: Round Packed Double Precision Floating-Point Values. 25088// 25089// Forms: 25090// 25091// VROUNDPD imm8 xmm xmm 25092// VROUNDPD imm8 m128 xmm 25093// VROUNDPD imm8 ymm ymm 25094// VROUNDPD imm8 m256 ymm 25095// Construct and append a VROUNDPD instruction to the active function. 25096// Operates on the global context. 25097func VROUNDPD(i, mxy, xy operand.Op) { ctx.VROUNDPD(i, mxy, xy) } 25098 25099// VROUNDPS: Round Packed Single Precision Floating-Point Values. 25100// 25101// Forms: 25102// 25103// VROUNDPS imm8 xmm xmm 25104// VROUNDPS imm8 m128 xmm 25105// VROUNDPS imm8 ymm ymm 25106// VROUNDPS imm8 m256 ymm 25107// Construct and append a VROUNDPS instruction to the active function. 25108func (c *Context) VROUNDPS(i, mxy, xy operand.Op) { 25109 if inst, err := x86.VROUNDPS(i, mxy, xy); err == nil { 25110 c.Instruction(inst) 25111 } else { 25112 c.adderror(err) 25113 } 25114} 25115 25116// VROUNDPS: Round Packed Single Precision Floating-Point Values. 25117// 25118// Forms: 25119// 25120// VROUNDPS imm8 xmm xmm 25121// VROUNDPS imm8 m128 xmm 25122// VROUNDPS imm8 ymm ymm 25123// VROUNDPS imm8 m256 ymm 25124// Construct and append a VROUNDPS instruction to the active function. 25125// Operates on the global context. 25126func VROUNDPS(i, mxy, xy operand.Op) { ctx.VROUNDPS(i, mxy, xy) } 25127 25128// VROUNDSD: Round Scalar Double Precision Floating-Point Values. 25129// 25130// Forms: 25131// 25132// VROUNDSD imm8 xmm xmm xmm 25133// VROUNDSD imm8 m64 xmm xmm 25134// Construct and append a VROUNDSD instruction to the active function. 25135func (c *Context) VROUNDSD(i, mx, x, x1 operand.Op) { 25136 if inst, err := x86.VROUNDSD(i, mx, x, x1); err == nil { 25137 c.Instruction(inst) 25138 } else { 25139 c.adderror(err) 25140 } 25141} 25142 25143// VROUNDSD: Round Scalar Double Precision Floating-Point Values. 25144// 25145// Forms: 25146// 25147// VROUNDSD imm8 xmm xmm xmm 25148// VROUNDSD imm8 m64 xmm xmm 25149// Construct and append a VROUNDSD instruction to the active function. 25150// Operates on the global context. 25151func VROUNDSD(i, mx, x, x1 operand.Op) { ctx.VROUNDSD(i, mx, x, x1) } 25152 25153// VROUNDSS: Round Scalar Single Precision Floating-Point Values. 25154// 25155// Forms: 25156// 25157// VROUNDSS imm8 xmm xmm xmm 25158// VROUNDSS imm8 m32 xmm xmm 25159// Construct and append a VROUNDSS instruction to the active function. 25160func (c *Context) VROUNDSS(i, mx, x, x1 operand.Op) { 25161 if inst, err := x86.VROUNDSS(i, mx, x, x1); err == nil { 25162 c.Instruction(inst) 25163 } else { 25164 c.adderror(err) 25165 } 25166} 25167 25168// VROUNDSS: Round Scalar Single Precision Floating-Point Values. 25169// 25170// Forms: 25171// 25172// VROUNDSS imm8 xmm xmm xmm 25173// VROUNDSS imm8 m32 xmm xmm 25174// Construct and append a VROUNDSS instruction to the active function. 25175// Operates on the global context. 25176func VROUNDSS(i, mx, x, x1 operand.Op) { ctx.VROUNDSS(i, mx, x, x1) } 25177 25178// VRSQRTPS: Compute Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values. 25179// 25180// Forms: 25181// 25182// VRSQRTPS xmm xmm 25183// VRSQRTPS m128 xmm 25184// VRSQRTPS ymm ymm 25185// VRSQRTPS m256 ymm 25186// Construct and append a VRSQRTPS instruction to the active function. 25187func (c *Context) VRSQRTPS(mxy, xy operand.Op) { 25188 if inst, err := x86.VRSQRTPS(mxy, xy); err == nil { 25189 c.Instruction(inst) 25190 } else { 25191 c.adderror(err) 25192 } 25193} 25194 25195// VRSQRTPS: Compute Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values. 25196// 25197// Forms: 25198// 25199// VRSQRTPS xmm xmm 25200// VRSQRTPS m128 xmm 25201// VRSQRTPS ymm ymm 25202// VRSQRTPS m256 ymm 25203// Construct and append a VRSQRTPS instruction to the active function. 25204// Operates on the global context. 25205func VRSQRTPS(mxy, xy operand.Op) { ctx.VRSQRTPS(mxy, xy) } 25206 25207// VRSQRTSS: Compute Reciprocal of Square Root of Scalar Single-Precision Floating-Point Value. 25208// 25209// Forms: 25210// 25211// VRSQRTSS xmm xmm xmm 25212// VRSQRTSS m32 xmm xmm 25213// Construct and append a VRSQRTSS instruction to the active function. 25214func (c *Context) VRSQRTSS(mx, x, x1 operand.Op) { 25215 if inst, err := x86.VRSQRTSS(mx, x, x1); err == nil { 25216 c.Instruction(inst) 25217 } else { 25218 c.adderror(err) 25219 } 25220} 25221 25222// VRSQRTSS: Compute Reciprocal of Square Root of Scalar Single-Precision Floating-Point Value. 25223// 25224// Forms: 25225// 25226// VRSQRTSS xmm xmm xmm 25227// VRSQRTSS m32 xmm xmm 25228// Construct and append a VRSQRTSS instruction to the active function. 25229// Operates on the global context. 25230func VRSQRTSS(mx, x, x1 operand.Op) { ctx.VRSQRTSS(mx, x, x1) } 25231 25232// VSHUFPD: Shuffle Packed Double-Precision Floating-Point Values. 25233// 25234// Forms: 25235// 25236// VSHUFPD imm8 xmm xmm xmm 25237// VSHUFPD imm8 m128 xmm xmm 25238// VSHUFPD imm8 ymm ymm ymm 25239// VSHUFPD imm8 m256 ymm ymm 25240// Construct and append a VSHUFPD instruction to the active function. 25241func (c *Context) VSHUFPD(i, mxy, xy, xy1 operand.Op) { 25242 if inst, err := x86.VSHUFPD(i, mxy, xy, xy1); err == nil { 25243 c.Instruction(inst) 25244 } else { 25245 c.adderror(err) 25246 } 25247} 25248 25249// VSHUFPD: Shuffle Packed Double-Precision Floating-Point Values. 25250// 25251// Forms: 25252// 25253// VSHUFPD imm8 xmm xmm xmm 25254// VSHUFPD imm8 m128 xmm xmm 25255// VSHUFPD imm8 ymm ymm ymm 25256// VSHUFPD imm8 m256 ymm ymm 25257// Construct and append a VSHUFPD instruction to the active function. 25258// Operates on the global context. 25259func VSHUFPD(i, mxy, xy, xy1 operand.Op) { ctx.VSHUFPD(i, mxy, xy, xy1) } 25260 25261// VSHUFPS: Shuffle Packed Single-Precision Floating-Point Values. 25262// 25263// Forms: 25264// 25265// VSHUFPS imm8 xmm xmm xmm 25266// VSHUFPS imm8 m128 xmm xmm 25267// VSHUFPS imm8 ymm ymm ymm 25268// VSHUFPS imm8 m256 ymm ymm 25269// Construct and append a VSHUFPS instruction to the active function. 25270func (c *Context) VSHUFPS(i, mxy, xy, xy1 operand.Op) { 25271 if inst, err := x86.VSHUFPS(i, mxy, xy, xy1); err == nil { 25272 c.Instruction(inst) 25273 } else { 25274 c.adderror(err) 25275 } 25276} 25277 25278// VSHUFPS: Shuffle Packed Single-Precision Floating-Point Values. 25279// 25280// Forms: 25281// 25282// VSHUFPS imm8 xmm xmm xmm 25283// VSHUFPS imm8 m128 xmm xmm 25284// VSHUFPS imm8 ymm ymm ymm 25285// VSHUFPS imm8 m256 ymm ymm 25286// Construct and append a VSHUFPS instruction to the active function. 25287// Operates on the global context. 25288func VSHUFPS(i, mxy, xy, xy1 operand.Op) { ctx.VSHUFPS(i, mxy, xy, xy1) } 25289 25290// VSQRTPD: Compute Square Roots of Packed Double-Precision Floating-Point Values. 25291// 25292// Forms: 25293// 25294// VSQRTPD xmm xmm 25295// VSQRTPD m128 xmm 25296// VSQRTPD ymm ymm 25297// VSQRTPD m256 ymm 25298// Construct and append a VSQRTPD instruction to the active function. 25299func (c *Context) VSQRTPD(mxy, xy operand.Op) { 25300 if inst, err := x86.VSQRTPD(mxy, xy); err == nil { 25301 c.Instruction(inst) 25302 } else { 25303 c.adderror(err) 25304 } 25305} 25306 25307// VSQRTPD: Compute Square Roots of Packed Double-Precision Floating-Point Values. 25308// 25309// Forms: 25310// 25311// VSQRTPD xmm xmm 25312// VSQRTPD m128 xmm 25313// VSQRTPD ymm ymm 25314// VSQRTPD m256 ymm 25315// Construct and append a VSQRTPD instruction to the active function. 25316// Operates on the global context. 25317func VSQRTPD(mxy, xy operand.Op) { ctx.VSQRTPD(mxy, xy) } 25318 25319// VSQRTPS: Compute Square Roots of Packed Single-Precision Floating-Point Values. 25320// 25321// Forms: 25322// 25323// VSQRTPS xmm xmm 25324// VSQRTPS m128 xmm 25325// VSQRTPS ymm ymm 25326// VSQRTPS m256 ymm 25327// Construct and append a VSQRTPS instruction to the active function. 25328func (c *Context) VSQRTPS(mxy, xy operand.Op) { 25329 if inst, err := x86.VSQRTPS(mxy, xy); err == nil { 25330 c.Instruction(inst) 25331 } else { 25332 c.adderror(err) 25333 } 25334} 25335 25336// VSQRTPS: Compute Square Roots of Packed Single-Precision Floating-Point Values. 25337// 25338// Forms: 25339// 25340// VSQRTPS xmm xmm 25341// VSQRTPS m128 xmm 25342// VSQRTPS ymm ymm 25343// VSQRTPS m256 ymm 25344// Construct and append a VSQRTPS instruction to the active function. 25345// Operates on the global context. 25346func VSQRTPS(mxy, xy operand.Op) { ctx.VSQRTPS(mxy, xy) } 25347 25348// VSQRTSD: Compute Square Root of Scalar Double-Precision Floating-Point Value. 25349// 25350// Forms: 25351// 25352// VSQRTSD xmm xmm xmm 25353// VSQRTSD m64 xmm xmm 25354// Construct and append a VSQRTSD instruction to the active function. 25355func (c *Context) VSQRTSD(mx, x, x1 operand.Op) { 25356 if inst, err := x86.VSQRTSD(mx, x, x1); err == nil { 25357 c.Instruction(inst) 25358 } else { 25359 c.adderror(err) 25360 } 25361} 25362 25363// VSQRTSD: Compute Square Root of Scalar Double-Precision Floating-Point Value. 25364// 25365// Forms: 25366// 25367// VSQRTSD xmm xmm xmm 25368// VSQRTSD m64 xmm xmm 25369// Construct and append a VSQRTSD instruction to the active function. 25370// Operates on the global context. 25371func VSQRTSD(mx, x, x1 operand.Op) { ctx.VSQRTSD(mx, x, x1) } 25372 25373// VSQRTSS: Compute Square Root of Scalar Single-Precision Floating-Point Value. 25374// 25375// Forms: 25376// 25377// VSQRTSS xmm xmm xmm 25378// VSQRTSS m32 xmm xmm 25379// Construct and append a VSQRTSS instruction to the active function. 25380func (c *Context) VSQRTSS(mx, x, x1 operand.Op) { 25381 if inst, err := x86.VSQRTSS(mx, x, x1); err == nil { 25382 c.Instruction(inst) 25383 } else { 25384 c.adderror(err) 25385 } 25386} 25387 25388// VSQRTSS: Compute Square Root of Scalar Single-Precision Floating-Point Value. 25389// 25390// Forms: 25391// 25392// VSQRTSS xmm xmm xmm 25393// VSQRTSS m32 xmm xmm 25394// Construct and append a VSQRTSS instruction to the active function. 25395// Operates on the global context. 25396func VSQRTSS(mx, x, x1 operand.Op) { ctx.VSQRTSS(mx, x, x1) } 25397 25398// VSTMXCSR: Store MXCSR Register State. 25399// 25400// Forms: 25401// 25402// VSTMXCSR m32 25403// Construct and append a VSTMXCSR instruction to the active function. 25404func (c *Context) VSTMXCSR(m operand.Op) { 25405 if inst, err := x86.VSTMXCSR(m); err == nil { 25406 c.Instruction(inst) 25407 } else { 25408 c.adderror(err) 25409 } 25410} 25411 25412// VSTMXCSR: Store MXCSR Register State. 25413// 25414// Forms: 25415// 25416// VSTMXCSR m32 25417// Construct and append a VSTMXCSR instruction to the active function. 25418// Operates on the global context. 25419func VSTMXCSR(m operand.Op) { ctx.VSTMXCSR(m) } 25420 25421// VSUBPD: Subtract Packed Double-Precision Floating-Point Values. 25422// 25423// Forms: 25424// 25425// VSUBPD xmm xmm xmm 25426// VSUBPD m128 xmm xmm 25427// VSUBPD ymm ymm ymm 25428// VSUBPD m256 ymm ymm 25429// Construct and append a VSUBPD instruction to the active function. 25430func (c *Context) VSUBPD(mxy, xy, xy1 operand.Op) { 25431 if inst, err := x86.VSUBPD(mxy, xy, xy1); err == nil { 25432 c.Instruction(inst) 25433 } else { 25434 c.adderror(err) 25435 } 25436} 25437 25438// VSUBPD: Subtract Packed Double-Precision Floating-Point Values. 25439// 25440// Forms: 25441// 25442// VSUBPD xmm xmm xmm 25443// VSUBPD m128 xmm xmm 25444// VSUBPD ymm ymm ymm 25445// VSUBPD m256 ymm ymm 25446// Construct and append a VSUBPD instruction to the active function. 25447// Operates on the global context. 25448func VSUBPD(mxy, xy, xy1 operand.Op) { ctx.VSUBPD(mxy, xy, xy1) } 25449 25450// VSUBPS: Subtract Packed Single-Precision Floating-Point Values. 25451// 25452// Forms: 25453// 25454// VSUBPS xmm xmm xmm 25455// VSUBPS m128 xmm xmm 25456// VSUBPS ymm ymm ymm 25457// VSUBPS m256 ymm ymm 25458// Construct and append a VSUBPS instruction to the active function. 25459func (c *Context) VSUBPS(mxy, xy, xy1 operand.Op) { 25460 if inst, err := x86.VSUBPS(mxy, xy, xy1); err == nil { 25461 c.Instruction(inst) 25462 } else { 25463 c.adderror(err) 25464 } 25465} 25466 25467// VSUBPS: Subtract Packed Single-Precision Floating-Point Values. 25468// 25469// Forms: 25470// 25471// VSUBPS xmm xmm xmm 25472// VSUBPS m128 xmm xmm 25473// VSUBPS ymm ymm ymm 25474// VSUBPS m256 ymm ymm 25475// Construct and append a VSUBPS instruction to the active function. 25476// Operates on the global context. 25477func VSUBPS(mxy, xy, xy1 operand.Op) { ctx.VSUBPS(mxy, xy, xy1) } 25478 25479// VSUBSD: Subtract Scalar Double-Precision Floating-Point Values. 25480// 25481// Forms: 25482// 25483// VSUBSD xmm xmm xmm 25484// VSUBSD m64 xmm xmm 25485// Construct and append a VSUBSD instruction to the active function. 25486func (c *Context) VSUBSD(mx, x, x1 operand.Op) { 25487 if inst, err := x86.VSUBSD(mx, x, x1); err == nil { 25488 c.Instruction(inst) 25489 } else { 25490 c.adderror(err) 25491 } 25492} 25493 25494// VSUBSD: Subtract Scalar Double-Precision Floating-Point Values. 25495// 25496// Forms: 25497// 25498// VSUBSD xmm xmm xmm 25499// VSUBSD m64 xmm xmm 25500// Construct and append a VSUBSD instruction to the active function. 25501// Operates on the global context. 25502func VSUBSD(mx, x, x1 operand.Op) { ctx.VSUBSD(mx, x, x1) } 25503 25504// VSUBSS: Subtract Scalar Single-Precision Floating-Point Values. 25505// 25506// Forms: 25507// 25508// VSUBSS xmm xmm xmm 25509// VSUBSS m32 xmm xmm 25510// Construct and append a VSUBSS instruction to the active function. 25511func (c *Context) VSUBSS(mx, x, x1 operand.Op) { 25512 if inst, err := x86.VSUBSS(mx, x, x1); err == nil { 25513 c.Instruction(inst) 25514 } else { 25515 c.adderror(err) 25516 } 25517} 25518 25519// VSUBSS: Subtract Scalar Single-Precision Floating-Point Values. 25520// 25521// Forms: 25522// 25523// VSUBSS xmm xmm xmm 25524// VSUBSS m32 xmm xmm 25525// Construct and append a VSUBSS instruction to the active function. 25526// Operates on the global context. 25527func VSUBSS(mx, x, x1 operand.Op) { ctx.VSUBSS(mx, x, x1) } 25528 25529// VTESTPD: Packed Double-Precision Floating-Point Bit Test. 25530// 25531// Forms: 25532// 25533// VTESTPD xmm xmm 25534// VTESTPD m128 xmm 25535// VTESTPD ymm ymm 25536// VTESTPD m256 ymm 25537// Construct and append a VTESTPD instruction to the active function. 25538func (c *Context) VTESTPD(mxy, xy operand.Op) { 25539 if inst, err := x86.VTESTPD(mxy, xy); err == nil { 25540 c.Instruction(inst) 25541 } else { 25542 c.adderror(err) 25543 } 25544} 25545 25546// VTESTPD: Packed Double-Precision Floating-Point Bit Test. 25547// 25548// Forms: 25549// 25550// VTESTPD xmm xmm 25551// VTESTPD m128 xmm 25552// VTESTPD ymm ymm 25553// VTESTPD m256 ymm 25554// Construct and append a VTESTPD instruction to the active function. 25555// Operates on the global context. 25556func VTESTPD(mxy, xy operand.Op) { ctx.VTESTPD(mxy, xy) } 25557 25558// VTESTPS: Packed Single-Precision Floating-Point Bit Test. 25559// 25560// Forms: 25561// 25562// VTESTPS xmm xmm 25563// VTESTPS m128 xmm 25564// VTESTPS ymm ymm 25565// VTESTPS m256 ymm 25566// Construct and append a VTESTPS instruction to the active function. 25567func (c *Context) VTESTPS(mxy, xy operand.Op) { 25568 if inst, err := x86.VTESTPS(mxy, xy); err == nil { 25569 c.Instruction(inst) 25570 } else { 25571 c.adderror(err) 25572 } 25573} 25574 25575// VTESTPS: Packed Single-Precision Floating-Point Bit Test. 25576// 25577// Forms: 25578// 25579// VTESTPS xmm xmm 25580// VTESTPS m128 xmm 25581// VTESTPS ymm ymm 25582// VTESTPS m256 ymm 25583// Construct and append a VTESTPS instruction to the active function. 25584// Operates on the global context. 25585func VTESTPS(mxy, xy operand.Op) { ctx.VTESTPS(mxy, xy) } 25586 25587// VUCOMISD: Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS. 25588// 25589// Forms: 25590// 25591// VUCOMISD xmm xmm 25592// VUCOMISD m64 xmm 25593// Construct and append a VUCOMISD instruction to the active function. 25594func (c *Context) VUCOMISD(mx, x operand.Op) { 25595 if inst, err := x86.VUCOMISD(mx, x); err == nil { 25596 c.Instruction(inst) 25597 } else { 25598 c.adderror(err) 25599 } 25600} 25601 25602// VUCOMISD: Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS. 25603// 25604// Forms: 25605// 25606// VUCOMISD xmm xmm 25607// VUCOMISD m64 xmm 25608// Construct and append a VUCOMISD instruction to the active function. 25609// Operates on the global context. 25610func VUCOMISD(mx, x operand.Op) { ctx.VUCOMISD(mx, x) } 25611 25612// VUCOMISS: Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS. 25613// 25614// Forms: 25615// 25616// VUCOMISS xmm xmm 25617// VUCOMISS m32 xmm 25618// Construct and append a VUCOMISS instruction to the active function. 25619func (c *Context) VUCOMISS(mx, x operand.Op) { 25620 if inst, err := x86.VUCOMISS(mx, x); err == nil { 25621 c.Instruction(inst) 25622 } else { 25623 c.adderror(err) 25624 } 25625} 25626 25627// VUCOMISS: Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS. 25628// 25629// Forms: 25630// 25631// VUCOMISS xmm xmm 25632// VUCOMISS m32 xmm 25633// Construct and append a VUCOMISS instruction to the active function. 25634// Operates on the global context. 25635func VUCOMISS(mx, x operand.Op) { ctx.VUCOMISS(mx, x) } 25636 25637// VUNPCKHPD: Unpack and Interleave High Packed Double-Precision Floating-Point Values. 25638// 25639// Forms: 25640// 25641// VUNPCKHPD xmm xmm xmm 25642// VUNPCKHPD m128 xmm xmm 25643// VUNPCKHPD ymm ymm ymm 25644// VUNPCKHPD m256 ymm ymm 25645// Construct and append a VUNPCKHPD instruction to the active function. 25646func (c *Context) VUNPCKHPD(mxy, xy, xy1 operand.Op) { 25647 if inst, err := x86.VUNPCKHPD(mxy, xy, xy1); err == nil { 25648 c.Instruction(inst) 25649 } else { 25650 c.adderror(err) 25651 } 25652} 25653 25654// VUNPCKHPD: Unpack and Interleave High Packed Double-Precision Floating-Point Values. 25655// 25656// Forms: 25657// 25658// VUNPCKHPD xmm xmm xmm 25659// VUNPCKHPD m128 xmm xmm 25660// VUNPCKHPD ymm ymm ymm 25661// VUNPCKHPD m256 ymm ymm 25662// Construct and append a VUNPCKHPD instruction to the active function. 25663// Operates on the global context. 25664func VUNPCKHPD(mxy, xy, xy1 operand.Op) { ctx.VUNPCKHPD(mxy, xy, xy1) } 25665 25666// VUNPCKHPS: Unpack and Interleave High Packed Single-Precision Floating-Point Values. 25667// 25668// Forms: 25669// 25670// VUNPCKHPS xmm xmm xmm 25671// VUNPCKHPS m128 xmm xmm 25672// VUNPCKHPS ymm ymm ymm 25673// VUNPCKHPS m256 ymm ymm 25674// Construct and append a VUNPCKHPS instruction to the active function. 25675func (c *Context) VUNPCKHPS(mxy, xy, xy1 operand.Op) { 25676 if inst, err := x86.VUNPCKHPS(mxy, xy, xy1); err == nil { 25677 c.Instruction(inst) 25678 } else { 25679 c.adderror(err) 25680 } 25681} 25682 25683// VUNPCKHPS: Unpack and Interleave High Packed Single-Precision Floating-Point Values. 25684// 25685// Forms: 25686// 25687// VUNPCKHPS xmm xmm xmm 25688// VUNPCKHPS m128 xmm xmm 25689// VUNPCKHPS ymm ymm ymm 25690// VUNPCKHPS m256 ymm ymm 25691// Construct and append a VUNPCKHPS instruction to the active function. 25692// Operates on the global context. 25693func VUNPCKHPS(mxy, xy, xy1 operand.Op) { ctx.VUNPCKHPS(mxy, xy, xy1) } 25694 25695// VUNPCKLPD: Unpack and Interleave Low Packed Double-Precision Floating-Point Values. 25696// 25697// Forms: 25698// 25699// VUNPCKLPD xmm xmm xmm 25700// VUNPCKLPD m128 xmm xmm 25701// VUNPCKLPD ymm ymm ymm 25702// VUNPCKLPD m256 ymm ymm 25703// Construct and append a VUNPCKLPD instruction to the active function. 25704func (c *Context) VUNPCKLPD(mxy, xy, xy1 operand.Op) { 25705 if inst, err := x86.VUNPCKLPD(mxy, xy, xy1); err == nil { 25706 c.Instruction(inst) 25707 } else { 25708 c.adderror(err) 25709 } 25710} 25711 25712// VUNPCKLPD: Unpack and Interleave Low Packed Double-Precision Floating-Point Values. 25713// 25714// Forms: 25715// 25716// VUNPCKLPD xmm xmm xmm 25717// VUNPCKLPD m128 xmm xmm 25718// VUNPCKLPD ymm ymm ymm 25719// VUNPCKLPD m256 ymm ymm 25720// Construct and append a VUNPCKLPD instruction to the active function. 25721// Operates on the global context. 25722func VUNPCKLPD(mxy, xy, xy1 operand.Op) { ctx.VUNPCKLPD(mxy, xy, xy1) } 25723 25724// VUNPCKLPS: Unpack and Interleave Low Packed Single-Precision Floating-Point Values. 25725// 25726// Forms: 25727// 25728// VUNPCKLPS xmm xmm xmm 25729// VUNPCKLPS m128 xmm xmm 25730// VUNPCKLPS ymm ymm ymm 25731// VUNPCKLPS m256 ymm ymm 25732// Construct and append a VUNPCKLPS instruction to the active function. 25733func (c *Context) VUNPCKLPS(mxy, xy, xy1 operand.Op) { 25734 if inst, err := x86.VUNPCKLPS(mxy, xy, xy1); err == nil { 25735 c.Instruction(inst) 25736 } else { 25737 c.adderror(err) 25738 } 25739} 25740 25741// VUNPCKLPS: Unpack and Interleave Low Packed Single-Precision Floating-Point Values. 25742// 25743// Forms: 25744// 25745// VUNPCKLPS xmm xmm xmm 25746// VUNPCKLPS m128 xmm xmm 25747// VUNPCKLPS ymm ymm ymm 25748// VUNPCKLPS m256 ymm ymm 25749// Construct and append a VUNPCKLPS instruction to the active function. 25750// Operates on the global context. 25751func VUNPCKLPS(mxy, xy, xy1 operand.Op) { ctx.VUNPCKLPS(mxy, xy, xy1) } 25752 25753// VXORPD: Bitwise Logical XOR for Double-Precision Floating-Point Values. 25754// 25755// Forms: 25756// 25757// VXORPD xmm xmm xmm 25758// VXORPD m128 xmm xmm 25759// VXORPD ymm ymm ymm 25760// VXORPD m256 ymm ymm 25761// Construct and append a VXORPD instruction to the active function. 25762func (c *Context) VXORPD(mxy, xy, xy1 operand.Op) { 25763 if inst, err := x86.VXORPD(mxy, xy, xy1); err == nil { 25764 c.Instruction(inst) 25765 } else { 25766 c.adderror(err) 25767 } 25768} 25769 25770// VXORPD: Bitwise Logical XOR for Double-Precision Floating-Point Values. 25771// 25772// Forms: 25773// 25774// VXORPD xmm xmm xmm 25775// VXORPD m128 xmm xmm 25776// VXORPD ymm ymm ymm 25777// VXORPD m256 ymm ymm 25778// Construct and append a VXORPD instruction to the active function. 25779// Operates on the global context. 25780func VXORPD(mxy, xy, xy1 operand.Op) { ctx.VXORPD(mxy, xy, xy1) } 25781 25782// VXORPS: Bitwise Logical XOR for Single-Precision Floating-Point Values. 25783// 25784// Forms: 25785// 25786// VXORPS xmm xmm xmm 25787// VXORPS m128 xmm xmm 25788// VXORPS ymm ymm ymm 25789// VXORPS m256 ymm ymm 25790// Construct and append a VXORPS instruction to the active function. 25791func (c *Context) VXORPS(mxy, xy, xy1 operand.Op) { 25792 if inst, err := x86.VXORPS(mxy, xy, xy1); err == nil { 25793 c.Instruction(inst) 25794 } else { 25795 c.adderror(err) 25796 } 25797} 25798 25799// VXORPS: Bitwise Logical XOR for Single-Precision Floating-Point Values. 25800// 25801// Forms: 25802// 25803// VXORPS xmm xmm xmm 25804// VXORPS m128 xmm xmm 25805// VXORPS ymm ymm ymm 25806// VXORPS m256 ymm ymm 25807// Construct and append a VXORPS instruction to the active function. 25808// Operates on the global context. 25809func VXORPS(mxy, xy, xy1 operand.Op) { ctx.VXORPS(mxy, xy, xy1) } 25810 25811// VZEROALL: Zero All YMM Registers. 25812// 25813// Forms: 25814// 25815// VZEROALL 25816// Construct and append a VZEROALL instruction to the active function. 25817func (c *Context) VZEROALL() { 25818 if inst, err := x86.VZEROALL(); err == nil { 25819 c.Instruction(inst) 25820 } else { 25821 c.adderror(err) 25822 } 25823} 25824 25825// VZEROALL: Zero All YMM Registers. 25826// 25827// Forms: 25828// 25829// VZEROALL 25830// Construct and append a VZEROALL instruction to the active function. 25831// Operates on the global context. 25832func VZEROALL() { ctx.VZEROALL() } 25833 25834// VZEROUPPER: Zero Upper Bits of YMM Registers. 25835// 25836// Forms: 25837// 25838// VZEROUPPER 25839// Construct and append a VZEROUPPER instruction to the active function. 25840func (c *Context) VZEROUPPER() { 25841 if inst, err := x86.VZEROUPPER(); err == nil { 25842 c.Instruction(inst) 25843 } else { 25844 c.adderror(err) 25845 } 25846} 25847 25848// VZEROUPPER: Zero Upper Bits of YMM Registers. 25849// 25850// Forms: 25851// 25852// VZEROUPPER 25853// Construct and append a VZEROUPPER instruction to the active function. 25854// Operates on the global context. 25855func VZEROUPPER() { ctx.VZEROUPPER() } 25856 25857// XADDB: Exchange and Add. 25858// 25859// Forms: 25860// 25861// XADDB r8 r8 25862// XADDB r8 m8 25863// Construct and append a XADDB instruction to the active function. 25864func (c *Context) XADDB(r, mr operand.Op) { 25865 if inst, err := x86.XADDB(r, mr); err == nil { 25866 c.Instruction(inst) 25867 } else { 25868 c.adderror(err) 25869 } 25870} 25871 25872// XADDB: Exchange and Add. 25873// 25874// Forms: 25875// 25876// XADDB r8 r8 25877// XADDB r8 m8 25878// Construct and append a XADDB instruction to the active function. 25879// Operates on the global context. 25880func XADDB(r, mr operand.Op) { ctx.XADDB(r, mr) } 25881 25882// XADDL: Exchange and Add. 25883// 25884// Forms: 25885// 25886// XADDL r32 r32 25887// XADDL r32 m32 25888// Construct and append a XADDL instruction to the active function. 25889func (c *Context) XADDL(r, mr operand.Op) { 25890 if inst, err := x86.XADDL(r, mr); err == nil { 25891 c.Instruction(inst) 25892 } else { 25893 c.adderror(err) 25894 } 25895} 25896 25897// XADDL: Exchange and Add. 25898// 25899// Forms: 25900// 25901// XADDL r32 r32 25902// XADDL r32 m32 25903// Construct and append a XADDL instruction to the active function. 25904// Operates on the global context. 25905func XADDL(r, mr operand.Op) { ctx.XADDL(r, mr) } 25906 25907// XADDQ: Exchange and Add. 25908// 25909// Forms: 25910// 25911// XADDQ r64 r64 25912// XADDQ r64 m64 25913// Construct and append a XADDQ instruction to the active function. 25914func (c *Context) XADDQ(r, mr operand.Op) { 25915 if inst, err := x86.XADDQ(r, mr); err == nil { 25916 c.Instruction(inst) 25917 } else { 25918 c.adderror(err) 25919 } 25920} 25921 25922// XADDQ: Exchange and Add. 25923// 25924// Forms: 25925// 25926// XADDQ r64 r64 25927// XADDQ r64 m64 25928// Construct and append a XADDQ instruction to the active function. 25929// Operates on the global context. 25930func XADDQ(r, mr operand.Op) { ctx.XADDQ(r, mr) } 25931 25932// XADDW: Exchange and Add. 25933// 25934// Forms: 25935// 25936// XADDW r16 r16 25937// XADDW r16 m16 25938// Construct and append a XADDW instruction to the active function. 25939func (c *Context) XADDW(r, mr operand.Op) { 25940 if inst, err := x86.XADDW(r, mr); err == nil { 25941 c.Instruction(inst) 25942 } else { 25943 c.adderror(err) 25944 } 25945} 25946 25947// XADDW: Exchange and Add. 25948// 25949// Forms: 25950// 25951// XADDW r16 r16 25952// XADDW r16 m16 25953// Construct and append a XADDW instruction to the active function. 25954// Operates on the global context. 25955func XADDW(r, mr operand.Op) { ctx.XADDW(r, mr) } 25956 25957// XCHGB: Exchange Register/Memory with Register. 25958// 25959// Forms: 25960// 25961// XCHGB r8 r8 25962// XCHGB m8 r8 25963// XCHGB r8 m8 25964// Construct and append a XCHGB instruction to the active function. 25965func (c *Context) XCHGB(mr, mr1 operand.Op) { 25966 if inst, err := x86.XCHGB(mr, mr1); err == nil { 25967 c.Instruction(inst) 25968 } else { 25969 c.adderror(err) 25970 } 25971} 25972 25973// XCHGB: Exchange Register/Memory with Register. 25974// 25975// Forms: 25976// 25977// XCHGB r8 r8 25978// XCHGB m8 r8 25979// XCHGB r8 m8 25980// Construct and append a XCHGB instruction to the active function. 25981// Operates on the global context. 25982func XCHGB(mr, mr1 operand.Op) { ctx.XCHGB(mr, mr1) } 25983 25984// XCHGL: Exchange Register/Memory with Register. 25985// 25986// Forms: 25987// 25988// XCHGL r32 eax 25989// XCHGL eax r32 25990// XCHGL r32 r32 25991// XCHGL m32 r32 25992// XCHGL r32 m32 25993// Construct and append a XCHGL instruction to the active function. 25994func (c *Context) XCHGL(emr, emr1 operand.Op) { 25995 if inst, err := x86.XCHGL(emr, emr1); err == nil { 25996 c.Instruction(inst) 25997 } else { 25998 c.adderror(err) 25999 } 26000} 26001 26002// XCHGL: Exchange Register/Memory with Register. 26003// 26004// Forms: 26005// 26006// XCHGL r32 eax 26007// XCHGL eax r32 26008// XCHGL r32 r32 26009// XCHGL m32 r32 26010// XCHGL r32 m32 26011// Construct and append a XCHGL instruction to the active function. 26012// Operates on the global context. 26013func XCHGL(emr, emr1 operand.Op) { ctx.XCHGL(emr, emr1) } 26014 26015// XCHGQ: Exchange Register/Memory with Register. 26016// 26017// Forms: 26018// 26019// XCHGQ r64 rax 26020// XCHGQ rax r64 26021// XCHGQ r64 r64 26022// XCHGQ m64 r64 26023// XCHGQ r64 m64 26024// Construct and append a XCHGQ instruction to the active function. 26025func (c *Context) XCHGQ(mr, mr1 operand.Op) { 26026 if inst, err := x86.XCHGQ(mr, mr1); err == nil { 26027 c.Instruction(inst) 26028 } else { 26029 c.adderror(err) 26030 } 26031} 26032 26033// XCHGQ: Exchange Register/Memory with Register. 26034// 26035// Forms: 26036// 26037// XCHGQ r64 rax 26038// XCHGQ rax r64 26039// XCHGQ r64 r64 26040// XCHGQ m64 r64 26041// XCHGQ r64 m64 26042// Construct and append a XCHGQ instruction to the active function. 26043// Operates on the global context. 26044func XCHGQ(mr, mr1 operand.Op) { ctx.XCHGQ(mr, mr1) } 26045 26046// XCHGW: Exchange Register/Memory with Register. 26047// 26048// Forms: 26049// 26050// XCHGW r16 ax 26051// XCHGW ax r16 26052// XCHGW r16 r16 26053// XCHGW m16 r16 26054// XCHGW r16 m16 26055// Construct and append a XCHGW instruction to the active function. 26056func (c *Context) XCHGW(amr, amr1 operand.Op) { 26057 if inst, err := x86.XCHGW(amr, amr1); err == nil { 26058 c.Instruction(inst) 26059 } else { 26060 c.adderror(err) 26061 } 26062} 26063 26064// XCHGW: Exchange Register/Memory with Register. 26065// 26066// Forms: 26067// 26068// XCHGW r16 ax 26069// XCHGW ax r16 26070// XCHGW r16 r16 26071// XCHGW m16 r16 26072// XCHGW r16 m16 26073// Construct and append a XCHGW instruction to the active function. 26074// Operates on the global context. 26075func XCHGW(amr, amr1 operand.Op) { ctx.XCHGW(amr, amr1) } 26076 26077// XGETBV: Get Value of Extended Control Register. 26078// 26079// Forms: 26080// 26081// XGETBV 26082// Construct and append a XGETBV instruction to the active function. 26083func (c *Context) XGETBV() { 26084 if inst, err := x86.XGETBV(); err == nil { 26085 c.Instruction(inst) 26086 } else { 26087 c.adderror(err) 26088 } 26089} 26090 26091// XGETBV: Get Value of Extended Control Register. 26092// 26093// Forms: 26094// 26095// XGETBV 26096// Construct and append a XGETBV instruction to the active function. 26097// Operates on the global context. 26098func XGETBV() { ctx.XGETBV() } 26099 26100// XLAT: Table Look-up Translation. 26101// 26102// Forms: 26103// 26104// XLAT 26105// Construct and append a XLAT instruction to the active function. 26106func (c *Context) XLAT() { 26107 if inst, err := x86.XLAT(); err == nil { 26108 c.Instruction(inst) 26109 } else { 26110 c.adderror(err) 26111 } 26112} 26113 26114// XLAT: Table Look-up Translation. 26115// 26116// Forms: 26117// 26118// XLAT 26119// Construct and append a XLAT instruction to the active function. 26120// Operates on the global context. 26121func XLAT() { ctx.XLAT() } 26122 26123// XORB: Logical Exclusive OR. 26124// 26125// Forms: 26126// 26127// XORB imm8 al 26128// XORB imm8 r8 26129// XORB r8 r8 26130// XORB m8 r8 26131// XORB imm8 m8 26132// XORB r8 m8 26133// Construct and append a XORB instruction to the active function. 26134func (c *Context) XORB(imr, amr operand.Op) { 26135 if inst, err := x86.XORB(imr, amr); err == nil { 26136 c.Instruction(inst) 26137 } else { 26138 c.adderror(err) 26139 } 26140} 26141 26142// XORB: Logical Exclusive OR. 26143// 26144// Forms: 26145// 26146// XORB imm8 al 26147// XORB imm8 r8 26148// XORB r8 r8 26149// XORB m8 r8 26150// XORB imm8 m8 26151// XORB r8 m8 26152// Construct and append a XORB instruction to the active function. 26153// Operates on the global context. 26154func XORB(imr, amr operand.Op) { ctx.XORB(imr, amr) } 26155 26156// XORL: Logical Exclusive OR. 26157// 26158// Forms: 26159// 26160// XORL imm32 eax 26161// XORL imm8 r32 26162// XORL imm32 r32 26163// XORL r32 r32 26164// XORL m32 r32 26165// XORL imm8 m32 26166// XORL imm32 m32 26167// XORL r32 m32 26168// Construct and append a XORL instruction to the active function. 26169func (c *Context) XORL(imr, emr operand.Op) { 26170 if inst, err := x86.XORL(imr, emr); err == nil { 26171 c.Instruction(inst) 26172 } else { 26173 c.adderror(err) 26174 } 26175} 26176 26177// XORL: Logical Exclusive OR. 26178// 26179// Forms: 26180// 26181// XORL imm32 eax 26182// XORL imm8 r32 26183// XORL imm32 r32 26184// XORL r32 r32 26185// XORL m32 r32 26186// XORL imm8 m32 26187// XORL imm32 m32 26188// XORL r32 m32 26189// Construct and append a XORL instruction to the active function. 26190// Operates on the global context. 26191func XORL(imr, emr operand.Op) { ctx.XORL(imr, emr) } 26192 26193// XORPD: Bitwise Logical XOR for Double-Precision Floating-Point Values. 26194// 26195// Forms: 26196// 26197// XORPD xmm xmm 26198// XORPD m128 xmm 26199// Construct and append a XORPD instruction to the active function. 26200func (c *Context) XORPD(mx, x operand.Op) { 26201 if inst, err := x86.XORPD(mx, x); err == nil { 26202 c.Instruction(inst) 26203 } else { 26204 c.adderror(err) 26205 } 26206} 26207 26208// XORPD: Bitwise Logical XOR for Double-Precision Floating-Point Values. 26209// 26210// Forms: 26211// 26212// XORPD xmm xmm 26213// XORPD m128 xmm 26214// Construct and append a XORPD instruction to the active function. 26215// Operates on the global context. 26216func XORPD(mx, x operand.Op) { ctx.XORPD(mx, x) } 26217 26218// XORPS: Bitwise Logical XOR for Single-Precision Floating-Point Values. 26219// 26220// Forms: 26221// 26222// XORPS xmm xmm 26223// XORPS m128 xmm 26224// Construct and append a XORPS instruction to the active function. 26225func (c *Context) XORPS(mx, x operand.Op) { 26226 if inst, err := x86.XORPS(mx, x); err == nil { 26227 c.Instruction(inst) 26228 } else { 26229 c.adderror(err) 26230 } 26231} 26232 26233// XORPS: Bitwise Logical XOR for Single-Precision Floating-Point Values. 26234// 26235// Forms: 26236// 26237// XORPS xmm xmm 26238// XORPS m128 xmm 26239// Construct and append a XORPS instruction to the active function. 26240// Operates on the global context. 26241func XORPS(mx, x operand.Op) { ctx.XORPS(mx, x) } 26242 26243// XORQ: Logical Exclusive OR. 26244// 26245// Forms: 26246// 26247// XORQ imm32 rax 26248// XORQ imm8 r64 26249// XORQ imm32 r64 26250// XORQ r64 r64 26251// XORQ m64 r64 26252// XORQ imm8 m64 26253// XORQ imm32 m64 26254// XORQ r64 m64 26255// Construct and append a XORQ instruction to the active function. 26256func (c *Context) XORQ(imr, mr operand.Op) { 26257 if inst, err := x86.XORQ(imr, mr); err == nil { 26258 c.Instruction(inst) 26259 } else { 26260 c.adderror(err) 26261 } 26262} 26263 26264// XORQ: Logical Exclusive OR. 26265// 26266// Forms: 26267// 26268// XORQ imm32 rax 26269// XORQ imm8 r64 26270// XORQ imm32 r64 26271// XORQ r64 r64 26272// XORQ m64 r64 26273// XORQ imm8 m64 26274// XORQ imm32 m64 26275// XORQ r64 m64 26276// Construct and append a XORQ instruction to the active function. 26277// Operates on the global context. 26278func XORQ(imr, mr operand.Op) { ctx.XORQ(imr, mr) } 26279 26280// XORW: Logical Exclusive OR. 26281// 26282// Forms: 26283// 26284// XORW imm16 ax 26285// XORW imm8 r16 26286// XORW imm16 r16 26287// XORW r16 r16 26288// XORW m16 r16 26289// XORW imm8 m16 26290// XORW imm16 m16 26291// XORW r16 m16 26292// Construct and append a XORW instruction to the active function. 26293func (c *Context) XORW(imr, amr operand.Op) { 26294 if inst, err := x86.XORW(imr, amr); err == nil { 26295 c.Instruction(inst) 26296 } else { 26297 c.adderror(err) 26298 } 26299} 26300 26301// XORW: Logical Exclusive OR. 26302// 26303// Forms: 26304// 26305// XORW imm16 ax 26306// XORW imm8 r16 26307// XORW imm16 r16 26308// XORW r16 r16 26309// XORW m16 r16 26310// XORW imm8 m16 26311// XORW imm16 m16 26312// XORW r16 m16 26313// Construct and append a XORW instruction to the active function. 26314// Operates on the global context. 26315func XORW(imr, amr operand.Op) { ctx.XORW(imr, amr) } 26316