1 /*******************************************************************************
2 * Copyright 2016-2020 Intel Corporation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 *******************************************************************************/
16
17 /*******************************************************************************
18 * Copyright (c) 2007 MITSUNARI Shigeo
19 * All rights reserved.
20 *
21 * Redistribution and use in source and binary forms, with or without
22 * modification, are permitted provided that the following conditions are met:
23 *
24 * Redistributions of source code must retain the above copyright notice, this
25 * list of conditions and the following disclaimer.
26 * Redistributions in binary form must reproduce the above copyright notice,
27 * this list of conditions and the following disclaimer in the documentation
28 * and/or other materials provided with the distribution.
29 * Neither the name of the copyright owner nor the names of its contributors may
30 * be used to endorse or promote products derived from this software without
31 * specific prior written permission.
32 *
33 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
34 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
35 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
36 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
37 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
38 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
39 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
40 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
41 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
42 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
43 * THE POSSIBILITY OF SUCH DAMAGE.
44 *******************************************************************************/
45
getVersionString()46 const char *getVersionString() const { return "5.99"; }
adc(const Operand & op,uint32_t imm)47 void adc(const Operand& op, uint32_t imm) { opRM_I(op, imm, 0x10, 2); }
adc(const Operand & op1,const Operand & op2)48 void adc(const Operand& op1, const Operand& op2) { opRM_RM(op1, op2, 0x10); }
adcx(const Reg32e & reg,const Operand & op)49 void adcx(const Reg32e& reg, const Operand& op) { opGen(reg, op, 0xF6, 0x66, isREG32_REG32orMEM, NONE, 0x38); }
add(const Operand & op,uint32_t imm)50 void add(const Operand& op, uint32_t imm) { opRM_I(op, imm, 0x00, 0); }
add(const Operand & op1,const Operand & op2)51 void add(const Operand& op1, const Operand& op2) { opRM_RM(op1, op2, 0x00); }
addpd(const Xmm & xmm,const Operand & op)52 void addpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x58, 0x66, isXMM_XMMorMEM); }
addps(const Xmm & xmm,const Operand & op)53 void addps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x58, 0x100, isXMM_XMMorMEM); }
addsd(const Xmm & xmm,const Operand & op)54 void addsd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x58, 0xF2, isXMM_XMMorMEM); }
addss(const Xmm & xmm,const Operand & op)55 void addss(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x58, 0xF3, isXMM_XMMorMEM); }
addsubpd(const Xmm & xmm,const Operand & op)56 void addsubpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xD0, 0x66, isXMM_XMMorMEM); }
addsubps(const Xmm & xmm,const Operand & op)57 void addsubps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xD0, 0xF2, isXMM_XMMorMEM); }
adox(const Reg32e & reg,const Operand & op)58 void adox(const Reg32e& reg, const Operand& op) { opGen(reg, op, 0xF6, 0xF3, isREG32_REG32orMEM, NONE, 0x38); }
aesdec(const Xmm & xmm,const Operand & op)59 void aesdec(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xDE, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
aesdeclast(const Xmm & xmm,const Operand & op)60 void aesdeclast(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xDF, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
aesenc(const Xmm & xmm,const Operand & op)61 void aesenc(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xDC, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
aesenclast(const Xmm & xmm,const Operand & op)62 void aesenclast(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xDD, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
aesimc(const Xmm & xmm,const Operand & op)63 void aesimc(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xDB, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
aeskeygenassist(const Xmm & xmm,const Operand & op,uint8_t imm)64 void aeskeygenassist(const Xmm& xmm, const Operand& op, uint8_t imm) { opGen(xmm, op, 0xDF, 0x66, isXMM_XMMorMEM, imm, 0x3A); }
and_(const Operand & op,uint32_t imm)65 void and_(const Operand& op, uint32_t imm) { opRM_I(op, imm, 0x20, 4); }
and_(const Operand & op1,const Operand & op2)66 void and_(const Operand& op1, const Operand& op2) { opRM_RM(op1, op2, 0x20); }
andn(const Reg32e & r1,const Reg32e & r2,const Operand & op)67 void andn(const Reg32e& r1, const Reg32e& r2, const Operand& op) { opGpr(r1, r2, op, T_0F38, 0xf2, true); }
andnpd(const Xmm & xmm,const Operand & op)68 void andnpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x55, 0x66, isXMM_XMMorMEM); }
andnps(const Xmm & xmm,const Operand & op)69 void andnps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x55, 0x100, isXMM_XMMorMEM); }
andpd(const Xmm & xmm,const Operand & op)70 void andpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x54, 0x66, isXMM_XMMorMEM); }
andps(const Xmm & xmm,const Operand & op)71 void andps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x54, 0x100, isXMM_XMMorMEM); }
bextr(const Reg32e & r1,const Operand & op,const Reg32e & r2)72 void bextr(const Reg32e& r1, const Operand& op, const Reg32e& r2) { opGpr(r1, op, r2, T_0F38, 0xf7, false); }
blendpd(const Xmm & xmm,const Operand & op,int imm)73 void blendpd(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0x0D, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A); }
blendps(const Xmm & xmm,const Operand & op,int imm)74 void blendps(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0x0C, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A); }
blendvpd(const Xmm & xmm,const Operand & op)75 void blendvpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x15, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
blendvps(const Xmm & xmm,const Operand & op)76 void blendvps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x14, 0x66, isXMM_XMMorMEM, NONE, 0x38); }
blsi(const Reg32e & r,const Operand & op)77 void blsi(const Reg32e& r, const Operand& op) { opGpr(Reg32e(3, r.getBit()), op, r, T_0F38, 0xf3, false); }
blsmsk(const Reg32e & r,const Operand & op)78 void blsmsk(const Reg32e& r, const Operand& op) { opGpr(Reg32e(2, r.getBit()), op, r, T_0F38, 0xf3, false); }
blsr(const Reg32e & r,const Operand & op)79 void blsr(const Reg32e& r, const Operand& op) { opGpr(Reg32e(1, r.getBit()), op, r, T_0F38, 0xf3, false); }
bnd()80 void bnd() { db(0xF2); }
bndcl(const BoundsReg & bnd,const Operand & op)81 void bndcl(const BoundsReg& bnd, const Operand& op) { db(0xF3); opR_ModM(op, i32e, bnd.getIdx(), 0x0F, 0x1A, NONE, !op.isMEM()); }
bndcn(const BoundsReg & bnd,const Operand & op)82 void bndcn(const BoundsReg& bnd, const Operand& op) { db(0xF2); opR_ModM(op, i32e, bnd.getIdx(), 0x0F, 0x1B, NONE, !op.isMEM()); }
bndcu(const BoundsReg & bnd,const Operand & op)83 void bndcu(const BoundsReg& bnd, const Operand& op) { db(0xF2); opR_ModM(op, i32e, bnd.getIdx(), 0x0F, 0x1A, NONE, !op.isMEM()); }
bndldx(const BoundsReg & bnd,const Address & addr)84 void bndldx(const BoundsReg& bnd, const Address& addr) { opMIB(addr, bnd, 0x0F, 0x1A); }
bndmk(const BoundsReg & bnd,const Address & addr)85 void bndmk(const BoundsReg& bnd, const Address& addr) { db(0xF3); opModM(addr, bnd, 0x0F, 0x1B); }
bndmov(const Address & addr,const BoundsReg & bnd)86 void bndmov(const Address& addr, const BoundsReg& bnd) { db(0x66); opModM(addr, bnd, 0x0F, 0x1B); }
bndmov(const BoundsReg & bnd,const Operand & op)87 void bndmov(const BoundsReg& bnd, const Operand& op) { db(0x66); opModRM(bnd, op, op.isBNDREG(), op.isMEM(), 0x0F, 0x1A); }
bndstx(const Address & addr,const BoundsReg & bnd)88 void bndstx(const Address& addr, const BoundsReg& bnd) { opMIB(addr, bnd, 0x0F, 0x1B); }
bsf(const Reg & reg,const Operand & op)89 void bsf(const Reg®, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0xBC); }
bsr(const Reg & reg,const Operand & op)90 void bsr(const Reg®, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0xBD); }
bswap(const Reg32e & reg)91 void bswap(const Reg32e& reg) { opModR(Reg32(1), reg, 0x0F); }
bt(const Operand & op,const Reg & reg)92 void bt(const Operand& op, const Reg& reg) { opModRM(reg, op, op.isREG(16|32|64) && op.getBit() == reg.getBit(), op.isMEM(), 0x0f, 0xA3); }
bt(const Operand & op,uint8_t imm)93 void bt(const Operand& op, uint8_t imm) { opR_ModM(op, 16|32|64, 4, 0x0f, 0xba, NONE, false, 1); db(imm); }
btc(const Operand & op,const Reg & reg)94 void btc(const Operand& op, const Reg& reg) { opModRM(reg, op, op.isREG(16|32|64) && op.getBit() == reg.getBit(), op.isMEM(), 0x0f, 0xBB); }
btc(const Operand & op,uint8_t imm)95 void btc(const Operand& op, uint8_t imm) { opR_ModM(op, 16|32|64, 7, 0x0f, 0xba, NONE, false, 1); db(imm); }
btr(const Operand & op,const Reg & reg)96 void btr(const Operand& op, const Reg& reg) { opModRM(reg, op, op.isREG(16|32|64) && op.getBit() == reg.getBit(), op.isMEM(), 0x0f, 0xB3); }
btr(const Operand & op,uint8_t imm)97 void btr(const Operand& op, uint8_t imm) { opR_ModM(op, 16|32|64, 6, 0x0f, 0xba, NONE, false, 1); db(imm); }
bts(const Operand & op,const Reg & reg)98 void bts(const Operand& op, const Reg& reg) { opModRM(reg, op, op.isREG(16|32|64) && op.getBit() == reg.getBit(), op.isMEM(), 0x0f, 0xAB); }
bts(const Operand & op,uint8_t imm)99 void bts(const Operand& op, uint8_t imm) { opR_ModM(op, 16|32|64, 5, 0x0f, 0xba, NONE, false, 1); db(imm); }
bzhi(const Reg32e & r1,const Operand & op,const Reg32e & r2)100 void bzhi(const Reg32e& r1, const Operand& op, const Reg32e& r2) { opGpr(r1, op, r2, T_0F38, 0xf5, false); }
cbw()101 void cbw() { db(0x66); db(0x98); }
cdq()102 void cdq() { db(0x99); }
clc()103 void clc() { db(0xF8); }
cld()104 void cld() { db(0xFC); }
clflush(const Address & addr)105 void clflush(const Address& addr) { opModM(addr, Reg32(7), 0x0F, 0xAE); }
clflushopt(const Address & addr)106 void clflushopt(const Address& addr) { db(0x66); opModM(addr, Reg32(7), 0x0F, 0xAE); }
cli()107 void cli() { db(0xFA); }
clzero()108 void clzero() { db(0x0F); db(0x01); db(0xFC); }
cmc()109 void cmc() { db(0xF5); }
cmova(const Reg & reg,const Operand & op)110 void cmova(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 7); }//-V524
cmovae(const Reg & reg,const Operand & op)111 void cmovae(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 3); }//-V524
cmovb(const Reg & reg,const Operand & op)112 void cmovb(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 2); }//-V524
cmovbe(const Reg & reg,const Operand & op)113 void cmovbe(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 6); }//-V524
cmovc(const Reg & reg,const Operand & op)114 void cmovc(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 2); }//-V524
cmove(const Reg & reg,const Operand & op)115 void cmove(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 4); }//-V524
cmovg(const Reg & reg,const Operand & op)116 void cmovg(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 15); }//-V524
cmovge(const Reg & reg,const Operand & op)117 void cmovge(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 13); }//-V524
cmovl(const Reg & reg,const Operand & op)118 void cmovl(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 12); }//-V524
cmovle(const Reg & reg,const Operand & op)119 void cmovle(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 14); }//-V524
cmovna(const Reg & reg,const Operand & op)120 void cmovna(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 6); }//-V524
cmovnae(const Reg & reg,const Operand & op)121 void cmovnae(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 2); }//-V524
cmovnb(const Reg & reg,const Operand & op)122 void cmovnb(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 3); }//-V524
cmovnbe(const Reg & reg,const Operand & op)123 void cmovnbe(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 7); }//-V524
cmovnc(const Reg & reg,const Operand & op)124 void cmovnc(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 3); }//-V524
cmovne(const Reg & reg,const Operand & op)125 void cmovne(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 5); }//-V524
cmovng(const Reg & reg,const Operand & op)126 void cmovng(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 14); }//-V524
cmovnge(const Reg & reg,const Operand & op)127 void cmovnge(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 12); }//-V524
cmovnl(const Reg & reg,const Operand & op)128 void cmovnl(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 13); }//-V524
cmovnle(const Reg & reg,const Operand & op)129 void cmovnle(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 15); }//-V524
cmovno(const Reg & reg,const Operand & op)130 void cmovno(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 1); }//-V524
cmovnp(const Reg & reg,const Operand & op)131 void cmovnp(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 11); }//-V524
cmovns(const Reg & reg,const Operand & op)132 void cmovns(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 9); }//-V524
cmovnz(const Reg & reg,const Operand & op)133 void cmovnz(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 5); }//-V524
cmovo(const Reg & reg,const Operand & op)134 void cmovo(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 0); }//-V524
cmovp(const Reg & reg,const Operand & op)135 void cmovp(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 10); }//-V524
cmovpe(const Reg & reg,const Operand & op)136 void cmovpe(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 10); }//-V524
cmovpo(const Reg & reg,const Operand & op)137 void cmovpo(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 11); }//-V524
cmovs(const Reg & reg,const Operand & op)138 void cmovs(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 8); }//-V524
cmovz(const Reg & reg,const Operand & op)139 void cmovz(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | 4); }//-V524
cmp(const Operand & op,uint32_t imm)140 void cmp(const Operand& op, uint32_t imm) { opRM_I(op, imm, 0x38, 7); }
cmp(const Operand & op1,const Operand & op2)141 void cmp(const Operand& op1, const Operand& op2) { opRM_RM(op1, op2, 0x38); }
cmpeqpd(const Xmm & x,const Operand & op)142 void cmpeqpd(const Xmm& x, const Operand& op) { cmppd(x, op, 0); }
cmpeqps(const Xmm & x,const Operand & op)143 void cmpeqps(const Xmm& x, const Operand& op) { cmpps(x, op, 0); }
cmpeqsd(const Xmm & x,const Operand & op)144 void cmpeqsd(const Xmm& x, const Operand& op) { cmpsd(x, op, 0); }
cmpeqss(const Xmm & x,const Operand & op)145 void cmpeqss(const Xmm& x, const Operand& op) { cmpss(x, op, 0); }
cmplepd(const Xmm & x,const Operand & op)146 void cmplepd(const Xmm& x, const Operand& op) { cmppd(x, op, 2); }
cmpleps(const Xmm & x,const Operand & op)147 void cmpleps(const Xmm& x, const Operand& op) { cmpps(x, op, 2); }
cmplesd(const Xmm & x,const Operand & op)148 void cmplesd(const Xmm& x, const Operand& op) { cmpsd(x, op, 2); }
cmpless(const Xmm & x,const Operand & op)149 void cmpless(const Xmm& x, const Operand& op) { cmpss(x, op, 2); }
cmpltpd(const Xmm & x,const Operand & op)150 void cmpltpd(const Xmm& x, const Operand& op) { cmppd(x, op, 1); }
cmpltps(const Xmm & x,const Operand & op)151 void cmpltps(const Xmm& x, const Operand& op) { cmpps(x, op, 1); }
cmpltsd(const Xmm & x,const Operand & op)152 void cmpltsd(const Xmm& x, const Operand& op) { cmpsd(x, op, 1); }
cmpltss(const Xmm & x,const Operand & op)153 void cmpltss(const Xmm& x, const Operand& op) { cmpss(x, op, 1); }
cmpneqpd(const Xmm & x,const Operand & op)154 void cmpneqpd(const Xmm& x, const Operand& op) { cmppd(x, op, 4); }
cmpneqps(const Xmm & x,const Operand & op)155 void cmpneqps(const Xmm& x, const Operand& op) { cmpps(x, op, 4); }
cmpneqsd(const Xmm & x,const Operand & op)156 void cmpneqsd(const Xmm& x, const Operand& op) { cmpsd(x, op, 4); }
cmpneqss(const Xmm & x,const Operand & op)157 void cmpneqss(const Xmm& x, const Operand& op) { cmpss(x, op, 4); }
cmpnlepd(const Xmm & x,const Operand & op)158 void cmpnlepd(const Xmm& x, const Operand& op) { cmppd(x, op, 6); }
cmpnleps(const Xmm & x,const Operand & op)159 void cmpnleps(const Xmm& x, const Operand& op) { cmpps(x, op, 6); }
cmpnlesd(const Xmm & x,const Operand & op)160 void cmpnlesd(const Xmm& x, const Operand& op) { cmpsd(x, op, 6); }
cmpnless(const Xmm & x,const Operand & op)161 void cmpnless(const Xmm& x, const Operand& op) { cmpss(x, op, 6); }
cmpnltpd(const Xmm & x,const Operand & op)162 void cmpnltpd(const Xmm& x, const Operand& op) { cmppd(x, op, 5); }
cmpnltps(const Xmm & x,const Operand & op)163 void cmpnltps(const Xmm& x, const Operand& op) { cmpps(x, op, 5); }
cmpnltsd(const Xmm & x,const Operand & op)164 void cmpnltsd(const Xmm& x, const Operand& op) { cmpsd(x, op, 5); }
cmpnltss(const Xmm & x,const Operand & op)165 void cmpnltss(const Xmm& x, const Operand& op) { cmpss(x, op, 5); }
cmpordpd(const Xmm & x,const Operand & op)166 void cmpordpd(const Xmm& x, const Operand& op) { cmppd(x, op, 7); }
cmpordps(const Xmm & x,const Operand & op)167 void cmpordps(const Xmm& x, const Operand& op) { cmpps(x, op, 7); }
cmpordsd(const Xmm & x,const Operand & op)168 void cmpordsd(const Xmm& x, const Operand& op) { cmpsd(x, op, 7); }
cmpordss(const Xmm & x,const Operand & op)169 void cmpordss(const Xmm& x, const Operand& op) { cmpss(x, op, 7); }
cmppd(const Xmm & xmm,const Operand & op,uint8_t imm8)170 void cmppd(const Xmm& xmm, const Operand& op, uint8_t imm8) { opGen(xmm, op, 0xC2, 0x66, isXMM_XMMorMEM, imm8); }
cmpps(const Xmm & xmm,const Operand & op,uint8_t imm8)171 void cmpps(const Xmm& xmm, const Operand& op, uint8_t imm8) { opGen(xmm, op, 0xC2, 0x100, isXMM_XMMorMEM, imm8); }
cmpsb()172 void cmpsb() { db(0xA6); }
cmpsd()173 void cmpsd() { db(0xA7); }
cmpsd(const Xmm & xmm,const Operand & op,uint8_t imm8)174 void cmpsd(const Xmm& xmm, const Operand& op, uint8_t imm8) { opGen(xmm, op, 0xC2, 0xF2, isXMM_XMMorMEM, imm8); }
cmpss(const Xmm & xmm,const Operand & op,uint8_t imm8)175 void cmpss(const Xmm& xmm, const Operand& op, uint8_t imm8) { opGen(xmm, op, 0xC2, 0xF3, isXMM_XMMorMEM, imm8); }
cmpsw()176 void cmpsw() { db(0x66); db(0xA7); }
cmpunordpd(const Xmm & x,const Operand & op)177 void cmpunordpd(const Xmm& x, const Operand& op) { cmppd(x, op, 3); }
cmpunordps(const Xmm & x,const Operand & op)178 void cmpunordps(const Xmm& x, const Operand& op) { cmpps(x, op, 3); }
cmpunordsd(const Xmm & x,const Operand & op)179 void cmpunordsd(const Xmm& x, const Operand& op) { cmpsd(x, op, 3); }
cmpunordss(const Xmm & x,const Operand & op)180 void cmpunordss(const Xmm& x, const Operand& op) { cmpss(x, op, 3); }
cmpxchg(const Operand & op,const Reg & reg)181 void cmpxchg(const Operand& op, const Reg& reg) { opModRM(reg, op, (op.isREG() && reg.isREG() && op.getBit() == reg.getBit()), op.isMEM(), 0x0F, 0xB0 | (reg.isBit(8) ? 0 : 1)); }
cmpxchg8b(const Address & addr)182 void cmpxchg8b(const Address& addr) { opModM(addr, Reg32(1), 0x0F, 0xC7); }
comisd(const Xmm & xmm,const Operand & op)183 void comisd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x2F, 0x66, isXMM_XMMorMEM); }
comiss(const Xmm & xmm,const Operand & op)184 void comiss(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x2F, 0x100, isXMM_XMMorMEM); }
cpuid()185 void cpuid() { db(0x0F); db(0xA2); }
crc32(const Reg32e & reg,const Operand & op)186 void crc32(const Reg32e& reg, const Operand& op) { if (reg.isBit(32) && op.isBit(16)) db(0x66); db(0xF2); opModRM(reg, op, op.isREG(), op.isMEM(), 0x0F, 0x38, 0xF0 | (op.isBit(8) ? 0 : 1)); }
cvtdq2pd(const Xmm & xmm,const Operand & op)187 void cvtdq2pd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xE6, 0xF3, isXMM_XMMorMEM); }
cvtdq2ps(const Xmm & xmm,const Operand & op)188 void cvtdq2ps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5B, 0x100, isXMM_XMMorMEM); }
cvtpd2dq(const Xmm & xmm,const Operand & op)189 void cvtpd2dq(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xE6, 0xF2, isXMM_XMMorMEM); }
cvtpd2pi(const Operand & reg,const Operand & op)190 void cvtpd2pi(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2D, 0x66, isMMX_XMMorMEM); }
cvtpd2ps(const Xmm & xmm,const Operand & op)191 void cvtpd2ps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5A, 0x66, isXMM_XMMorMEM); }
cvtpi2pd(const Operand & reg,const Operand & op)192 void cvtpi2pd(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2A, 0x66, isXMM_MMXorMEM); }
cvtpi2ps(const Operand & reg,const Operand & op)193 void cvtpi2ps(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2A, 0x100, isXMM_MMXorMEM); }
cvtps2dq(const Xmm & xmm,const Operand & op)194 void cvtps2dq(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5B, 0x66, isXMM_XMMorMEM); }
cvtps2pd(const Xmm & xmm,const Operand & op)195 void cvtps2pd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5A, 0x100, isXMM_XMMorMEM); }
cvtps2pi(const Operand & reg,const Operand & op)196 void cvtps2pi(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2D, 0x100, isMMX_XMMorMEM); }
cvtsd2si(const Operand & reg,const Operand & op)197 void cvtsd2si(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2D, 0xF2, isREG32_XMMorMEM); }
cvtsd2ss(const Xmm & xmm,const Operand & op)198 void cvtsd2ss(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5A, 0xF2, isXMM_XMMorMEM); }
cvtsi2sd(const Operand & reg,const Operand & op)199 void cvtsi2sd(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2A, 0xF2, isXMM_REG32orMEM); }
cvtsi2ss(const Operand & reg,const Operand & op)200 void cvtsi2ss(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2A, 0xF3, isXMM_REG32orMEM); }
cvtss2sd(const Xmm & xmm,const Operand & op)201 void cvtss2sd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5A, 0xF3, isXMM_XMMorMEM); }
cvtss2si(const Operand & reg,const Operand & op)202 void cvtss2si(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2D, 0xF3, isREG32_XMMorMEM); }
cvttpd2dq(const Xmm & xmm,const Operand & op)203 void cvttpd2dq(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0xE6, 0x66, isXMM_XMMorMEM); }
cvttpd2pi(const Operand & reg,const Operand & op)204 void cvttpd2pi(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2C, 0x66, isMMX_XMMorMEM); }
cvttps2dq(const Xmm & xmm,const Operand & op)205 void cvttps2dq(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5B, 0xF3, isXMM_XMMorMEM); }
cvttps2pi(const Operand & reg,const Operand & op)206 void cvttps2pi(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2C, 0x100, isMMX_XMMorMEM); }
cvttsd2si(const Operand & reg,const Operand & op)207 void cvttsd2si(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2C, 0xF2, isREG32_XMMorMEM); }
cvttss2si(const Operand & reg,const Operand & op)208 void cvttss2si(const Operand& reg, const Operand& op) { opGen(reg, op, 0x2C, 0xF3, isREG32_XMMorMEM); }
cwd()209 void cwd() { db(0x66); db(0x99); }
cwde()210 void cwde() { db(0x98); }
dec(const Operand & op)211 void dec(const Operand& op) { opIncDec(op, 0x48, 1); }
div(const Operand & op)212 void div(const Operand& op) { opR_ModM(op, 0, 6, 0xF6); }
divpd(const Xmm & xmm,const Operand & op)213 void divpd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5E, 0x66, isXMM_XMMorMEM); }
divps(const Xmm & xmm,const Operand & op)214 void divps(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5E, 0x100, isXMM_XMMorMEM); }
divsd(const Xmm & xmm,const Operand & op)215 void divsd(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5E, 0xF2, isXMM_XMMorMEM); }
divss(const Xmm & xmm,const Operand & op)216 void divss(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x5E, 0xF3, isXMM_XMMorMEM); }
dppd(const Xmm & xmm,const Operand & op,int imm)217 void dppd(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0x41, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A); }
dpps(const Xmm & xmm,const Operand & op,int imm)218 void dpps(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0x40, 0x66, isXMM_XMMorMEM, static_cast<uint8_t>(imm), 0x3A); }
emms()219 void emms() { db(0x0F); db(0x77); }
enter(uint16_t x,uint8_t y)220 void enter(uint16_t x, uint8_t y) { db(0xC8); dw(x); db(y); }
extractps(const Operand & op,const Xmm & xmm,uint8_t imm)221 void extractps(const Operand& op, const Xmm& xmm, uint8_t imm) { opExt(op, xmm, 0x17, imm); }
f2xm1()222 void f2xm1() { db(0xD9); db(0xF0); }
fabs()223 void fabs() { db(0xD9); db(0xE1); }
fadd(const Address & addr)224 void fadd(const Address& addr) { opFpuMem(addr, 0x00, 0xD8, 0xDC, 0, 0); }
fadd(const Fpu & reg1)225 void fadd(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xD8C0, 0xDCC0); }
fadd(const Fpu & reg1,const Fpu & reg2)226 void fadd(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xD8C0, 0xDCC0); }
faddp()227 void faddp() { db(0xDE); db(0xC1); }
faddp(const Fpu & reg1)228 void faddp(const Fpu& reg1) { opFpuFpu(reg1, st0, 0x0000, 0xDEC0); }
faddp(const Fpu & reg1,const Fpu & reg2)229 void faddp(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0x0000, 0xDEC0); }
fbld(const Address & addr)230 void fbld(const Address& addr) { opModM(addr, Reg32(4), 0xDF, 0x100); }
fbstp(const Address & addr)231 void fbstp(const Address& addr) { opModM(addr, Reg32(6), 0xDF, 0x100); }
fchs()232 void fchs() { db(0xD9); db(0xE0); }
fclex()233 void fclex() { db(0x9B); db(0xDB); db(0xE2); }
fcmovb(const Fpu & reg1)234 void fcmovb(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDAC0, 0x00C0); }
fcmovb(const Fpu & reg1,const Fpu & reg2)235 void fcmovb(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDAC0, 0x00C0); }
fcmovbe(const Fpu & reg1)236 void fcmovbe(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDAD0, 0x00D0); }
fcmovbe(const Fpu & reg1,const Fpu & reg2)237 void fcmovbe(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDAD0, 0x00D0); }
fcmove(const Fpu & reg1)238 void fcmove(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDAC8, 0x00C8); }
fcmove(const Fpu & reg1,const Fpu & reg2)239 void fcmove(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDAC8, 0x00C8); }
fcmovnb(const Fpu & reg1)240 void fcmovnb(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDBC0, 0x00C0); }
fcmovnb(const Fpu & reg1,const Fpu & reg2)241 void fcmovnb(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDBC0, 0x00C0); }
fcmovnbe(const Fpu & reg1)242 void fcmovnbe(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDBD0, 0x00D0); }
fcmovnbe(const Fpu & reg1,const Fpu & reg2)243 void fcmovnbe(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDBD0, 0x00D0); }
fcmovne(const Fpu & reg1)244 void fcmovne(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDBC8, 0x00C8); }
fcmovne(const Fpu & reg1,const Fpu & reg2)245 void fcmovne(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDBC8, 0x00C8); }
fcmovnu(const Fpu & reg1)246 void fcmovnu(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDBD8, 0x00D8); }
fcmovnu(const Fpu & reg1,const Fpu & reg2)247 void fcmovnu(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDBD8, 0x00D8); }
fcmovu(const Fpu & reg1)248 void fcmovu(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDAD8, 0x00D8); }
fcmovu(const Fpu & reg1,const Fpu & reg2)249 void fcmovu(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDAD8, 0x00D8); }
fcom()250 void fcom() { db(0xD8); db(0xD1); }
fcom(const Address & addr)251 void fcom(const Address& addr) { opFpuMem(addr, 0x00, 0xD8, 0xDC, 2, 0); }
fcom(const Fpu & reg)252 void fcom(const Fpu& reg) { opFpu(reg, 0xD8, 0xD0); }
fcomi(const Fpu & reg1)253 void fcomi(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDBF0, 0x00F0); }
fcomi(const Fpu & reg1,const Fpu & reg2)254 void fcomi(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDBF0, 0x00F0); }
fcomip(const Fpu & reg1)255 void fcomip(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xDFF0, 0x00F0); }
fcomip(const Fpu & reg1,const Fpu & reg2)256 void fcomip(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xDFF0, 0x00F0); }
fcomp()257 void fcomp() { db(0xD8); db(0xD9); }
fcomp(const Address & addr)258 void fcomp(const Address& addr) { opFpuMem(addr, 0x00, 0xD8, 0xDC, 3, 0); }
fcomp(const Fpu & reg)259 void fcomp(const Fpu& reg) { opFpu(reg, 0xD8, 0xD8); }
fcompp()260 void fcompp() { db(0xDE); db(0xD9); }
fcos()261 void fcos() { db(0xD9); db(0xFF); }
fdecstp()262 void fdecstp() { db(0xD9); db(0xF6); }
fdiv(const Address & addr)263 void fdiv(const Address& addr) { opFpuMem(addr, 0x00, 0xD8, 0xDC, 6, 0); }
fdiv(const Fpu & reg1)264 void fdiv(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xD8F0, 0xDCF8); }
fdiv(const Fpu & reg1,const Fpu & reg2)265 void fdiv(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xD8F0, 0xDCF8); }
fdivp()266 void fdivp() { db(0xDE); db(0xF9); }
fdivp(const Fpu & reg1)267 void fdivp(const Fpu& reg1) { opFpuFpu(reg1, st0, 0x0000, 0xDEF8); }
fdivp(const Fpu & reg1,const Fpu & reg2)268 void fdivp(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0x0000, 0xDEF8); }
fdivr(const Address & addr)269 void fdivr(const Address& addr) { opFpuMem(addr, 0x00, 0xD8, 0xDC, 7, 0); }
fdivr(const Fpu & reg1)270 void fdivr(const Fpu& reg1) { opFpuFpu(st0, reg1, 0xD8F8, 0xDCF0); }
fdivr(const Fpu & reg1,const Fpu & reg2)271 void fdivr(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0xD8F8, 0xDCF0); }
fdivrp()272 void fdivrp() { db(0xDE); db(0xF1); }
fdivrp(const Fpu & reg1)273 void fdivrp(const Fpu& reg1) { opFpuFpu(reg1, st0, 0x0000, 0xDEF0); }
fdivrp(const Fpu & reg1,const Fpu & reg2)274 void fdivrp(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0x0000, 0xDEF0); }
ffree(const Fpu & reg)275 void ffree(const Fpu& reg) { opFpu(reg, 0xDD, 0xC0); }
fiadd(const Address & addr)276 void fiadd(const Address& addr) { opFpuMem(addr, 0xDE, 0xDA, 0x00, 0, 0); }
ficom(const Address & addr)277 void ficom(const Address& addr) { opFpuMem(addr, 0xDE, 0xDA, 0x00, 2, 0); }
ficomp(const Address & addr)278 void ficomp(const Address& addr) { opFpuMem(addr, 0xDE, 0xDA, 0x00, 3, 0); }
fidiv(const Address & addr)279 void fidiv(const Address& addr) { opFpuMem(addr, 0xDE, 0xDA, 0x00, 6, 0); }
fidivr(const Address & addr)280 void fidivr(const Address& addr) { opFpuMem(addr, 0xDE, 0xDA, 0x00, 7, 0); }
fild(const Address & addr)281 void fild(const Address& addr) { opFpuMem(addr, 0xDF, 0xDB, 0xDF, 0, 5); }
fimul(const Address & addr)282 void fimul(const Address& addr) { opFpuMem(addr, 0xDE, 0xDA, 0x00, 1, 0); }
fincstp()283 void fincstp() { db(0xD9); db(0xF7); }
finit()284 void finit() { db(0x9B); db(0xDB); db(0xE3); }
fist(const Address & addr)285 void fist(const Address& addr) { opFpuMem(addr, 0xDF, 0xDB, 0x00, 2, 0); }
fistp(const Address & addr)286 void fistp(const Address& addr) { opFpuMem(addr, 0xDF, 0xDB, 0xDF, 3, 7); }
fisttp(const Address & addr)287 void fisttp(const Address& addr) { opFpuMem(addr, 0xDF, 0xDB, 0xDD, 1, 0); }
fisub(const Address & addr)288 void fisub(const Address& addr) { opFpuMem(addr, 0xDE, 0xDA, 0x00, 4, 0); }
fisubr(const Address & addr)289 void fisubr(const Address& addr) { opFpuMem(addr, 0xDE, 0xDA, 0x00, 5, 0); }
fld(const Address & addr)290 void fld(const Address& addr) { opFpuMem(addr, 0x00, 0xD9, 0xDD, 0, 0); }
fld(const Fpu & reg)291 void fld(const Fpu& reg) { opFpu(reg, 0xD9, 0xC0); }
fld1()292 void fld1() { db(0xD9); db(0xE8); }
fldcw(const Address & addr)293 void fldcw(const Address& addr) { opModM(addr, Reg32(5), 0xD9, 0x100); }
fldenv(const Address & addr)294 void fldenv(const Address& addr) { opModM(addr, Reg32(4), 0xD9, 0x100); }
fldl2e()295