1 #define XBYAK_DONT_READ_LIST
2 #include <stdio.h>
3 #include <string.h>
4 #include "xbyak/xbyak.h"
5 #define NUM_OF_ARRAY(x) (sizeof(x) / sizeof(x[0]))
6
7 using namespace Xbyak;
8 #ifdef _MSC_VER
9 #pragma warning(disable : 4996) // scanf
10 #define snprintf _snprintf_s
11 #endif
12
13 #include "avx_type.hpp"
14 /*
15 reg = cx/ecx/rcx
16 insert 0x67 if prefix is true
17 */
put_jREGz(const char * reg,bool prefix)18 void put_jREGz(const char *reg, bool prefix)
19 {
20 printf("void j%sz(std::string label) { %sopJmp(label, T_SHORT, 0xe3, 0, 0); }\n", reg, prefix ? "db(0x67); " : "");
21 printf("void j%sz(const Label& label) { %sopJmp(label, T_SHORT, 0xe3, 0, 0); }\n", reg, prefix ? "db(0x67); " : "");
22 }
23
24 struct GenericTbl {
25 const char *name;
26 uint8 code1;
27 uint8 code2;
28 uint8 code3;
29 };
30
putGeneric(const GenericTbl * p,size_t n)31 void putGeneric(const GenericTbl *p, size_t n)
32 {
33 for (size_t i = 0; i < n; i++) {
34 printf("void %s() { db(0x%02X); ", p->name, p->code1);
35 if (p->code2) printf("db(0x%02X); ", p->code2);
36 if (p->code3) printf("db(0x%02X); ", p->code3);
37 printf("}\n");
38 p++;
39 }
40 }
41
putX_X_XM(bool omitOnly)42 void putX_X_XM(bool omitOnly)
43 {
44 // (x, x, x/m[, imm]) or (y, y, y/m[, imm])
45 {
46 const struct Tbl {
47 uint8 code;
48 const char *name;
49 int type;
50 bool hasIMM;
51 bool enableOmit;
52 int mode; // 1 : sse, 2 : avx, 3 : sse + avx
53 } tbl[] = {
54 { 0x0D, "blendpd", T_0F3A | T_66 | T_W0 | T_YMM, true, true, 3 },
55 { 0x0C, "blendps", T_0F3A | T_66 | T_W0 | T_YMM, true, true, 3 },
56 { 0x41, "dppd", T_0F3A | T_66 | T_W0, true, true, 3 },
57 { 0x40, "dpps", T_0F3A | T_66 | T_W0 | T_YMM, true, true, 3 },
58 { 0x42, "mpsadbw", T_0F3A | T_66 | T_W0 | T_YMM, true, true, 3 },
59 { 0x0E, "pblendw", T_0F3A | T_66 | T_W0 | T_YMM, true, true, 3 },
60 { 0x02, "pblendd", T_0F3A | T_66 | T_W0 | T_YMM, true, true, 2 },
61 { 0x0B, "roundsd", T_0F3A | T_66 | T_W0, true, true, 3 },
62 { 0x0A, "roundss", T_0F3A | T_66 | T_W0, true, true, 3 },
63 { 0x44, "pclmulqdq", T_0F3A | T_66 | T_W0 | T_YMM | T_EVEX, true, true, 3 },
64 { 0x0C, "permilps", T_0F38 | T_66 | T_W0 | T_YMM | T_EVEX | T_EW0 | T_B32, false, false, 2 },
65 { 0x0D, "permilpd", T_0F38 | T_66 | T_W0 | T_YMM | T_EVEX | T_EW1 | T_B64, false, false, 2 },
66
67 { 0x47, "psllvd", T_0F38 | T_66 | T_W0 | T_YMM | T_EVEX | T_EW0 | T_B32, false, false, 2 },
68 { 0x47, "psllvq", T_0F38 | T_66 | T_W1 | T_YMM | T_EVEX | T_EW1 | T_B64, false, false, 2 },
69 { 0x46, "psravd", T_0F38 | T_66 | T_W0 | T_YMM | T_EVEX | T_EW0 | T_B32, false, false, 2 },
70 { 0x45, "psrlvd", T_0F38 | T_66 | T_W0 | T_YMM | T_EVEX | T_EW0 | T_B32, false, false, 2 },
71 { 0x45, "psrlvq", T_0F38 | T_66 | T_W1 | T_YMM | T_EVEX | T_EW1 | T_B64, false, false, 2 },
72
73 { 0xC2, "cmppd", T_0F | T_66 | T_YMM, true, true, 2 },
74 { 0xC2, "cmpps", T_0F | T_YMM, true, true, 2 },
75 { 0xC2, "cmpsd", T_0F | T_F2, true, true, 2 },
76 { 0xC2, "cmpss", T_0F | T_F3, true, true, 2 },
77 { 0x5A, "cvtsd2ss", T_0F | T_F2 | T_EVEX | T_EW1 | T_N8 | T_ER_X, false, true, 2 },
78 { 0x5A, "cvtss2sd", T_0F | T_F3 | T_EVEX | T_EW0 | T_N4 | T_SAE_X, false, true, 2 },
79 { 0x21, "insertps", T_0F3A | T_66 | T_W0 | T_EVEX | T_EW0 | T_N4, true, true, 2 },
80 { 0x63, "packsswb", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
81 { 0x6B, "packssdw", T_0F | T_66 | T_YMM | T_EVEX | T_EW0 | T_B32, false, true, 2 },
82 { 0x67, "packuswb", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
83 { 0x2B, "packusdw", T_0F38 | T_66 | T_YMM | T_EVEX | T_EW0 | T_B32, false, true, 3 },
84
85 { 0xFC, "paddb", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
86 { 0xFD, "paddw", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
87 { 0xFE, "paddd", T_0F | T_66 | T_YMM | T_EVEX | T_EW0 | T_B32, false, true, 2 },
88 { 0xD4, "paddq", T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_B64, false, true, 2 },
89
90 { 0xEC, "paddsb", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
91 { 0xED, "paddsw", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
92
93 { 0xDC, "paddusb", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
94 { 0xDD, "paddusw", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
95
96 { 0x0F, "palignr", T_0F3A | T_66 | T_YMM | T_EVEX, true, true, 2 },
97
98 { 0xDB, "pand", T_0F | T_66 | T_YMM, false, true, 2 },
99 { 0xDF, "pandn", T_0F | T_66 | T_YMM, false, true, 2 },
100
101 { 0xE0, "pavgb", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
102 { 0xE3, "pavgw", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
103
104 { 0x74, "pcmpeqb", T_0F | T_66 | T_YMM, false, true, 2 },
105 { 0x75, "pcmpeqw", T_0F | T_66 | T_YMM, false, true, 2 },
106 { 0x76, "pcmpeqd", T_0F | T_66 | T_YMM, false, true, 2 },
107 { 0x29, "pcmpeqq", T_0F38 | T_66 | T_YMM, false, true, 3 },
108
109 { 0x64, "pcmpgtb", T_0F | T_66 | T_YMM, false, true, 2 },
110 { 0x65, "pcmpgtw", T_0F | T_66 | T_YMM, false, true, 2 },
111 { 0x66, "pcmpgtd", T_0F | T_66 | T_YMM, false, true, 2 },
112 { 0x37, "pcmpgtq", T_0F38 | T_66 | T_YMM, false, true, 3 },
113
114 { 0x01, "phaddw", T_0F38 | T_66 | T_YMM, false, true, 2 },
115 { 0x02, "phaddd", T_0F38 | T_66 | T_YMM, false, true, 2 },
116 { 0x03, "phaddsw", T_0F38 | T_66 | T_YMM, false, true, 2 },
117
118 { 0x05, "phsubw", T_0F38 | T_66 | T_YMM, false, true, 2 },
119 { 0x06, "phsubd", T_0F38 | T_66 | T_YMM, false, true, 2 },
120 { 0x07, "phsubsw", T_0F38 | T_66 | T_YMM, false, true, 2 },
121 { 0xF5, "pmaddwd", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
122 { 0x04, "pmaddubsw", T_0F38 | T_66 | T_YMM | T_EVEX, false, true, 2 },
123
124 { 0x3C, "pmaxsb", T_0F38 | T_66 | T_YMM | T_EVEX, false, true, 3 },
125 { 0xEE, "pmaxsw", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
126 { 0x3D, "pmaxsd", T_0F38 | T_66 | T_YMM | T_EVEX | T_EW0 | T_B32, false, true, 3 },
127
128 { 0xDE, "pmaxub", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
129 { 0x3E, "pmaxuw", T_0F38 | T_66 | T_YMM | T_EVEX, false, true, 3 },
130 { 0x3F, "pmaxud", T_0F38 | T_66 | T_YMM | T_EVEX | T_EW0 | T_B32, false, true, 3 },
131
132 { 0x38, "pminsb", T_0F38 | T_66 | T_YMM | T_EVEX, false, true, 3 },
133 { 0xEA, "pminsw", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
134 { 0x39, "pminsd", T_0F38 | T_66 | T_YMM | T_EVEX | T_EW0 | T_B32, false, true, 3 },
135
136 { 0xDA, "pminub", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
137 { 0x3A, "pminuw", T_0F38 | T_66 | T_YMM | T_EVEX, false, true, 3 },
138 { 0x3B, "pminud", T_0F38 | T_66 | T_YMM | T_EVEX | T_EW0 | T_B32, false, true, 3 },
139
140 { 0xE4, "pmulhuw", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
141 { 0x0B, "pmulhrsw", T_0F38 | T_66 | T_YMM | T_EVEX, false, true, 2 },
142 { 0xE5, "pmulhw", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
143 { 0xD5, "pmullw", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
144 { 0x40, "pmulld", T_0F38 | T_66 | T_YMM | T_EVEX | T_EW0 | T_B32, false, true, 3 },
145
146 { 0xF4, "pmuludq", T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_B64, false, true, 2 },
147 { 0x28, "pmuldq", T_0F38 | T_66 | T_YMM | T_EVEX | T_EW1 | T_B64, false, true, 3 },
148
149 { 0xEB, "por", T_0F | T_66 | T_YMM, false, true, 2 },
150 { 0xF6, "psadbw", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
151
152 { 0x00, "pshufb", T_0F38 | T_66 | T_YMM | T_EVEX, false, false, 2 },
153
154 { 0x08, "psignb", T_0F38 | T_66 | T_YMM, false, true, 2 },
155 { 0x09, "psignw", T_0F38 | T_66 | T_YMM, false, true, 2 },
156 { 0x0A, "psignd", T_0F38 | T_66 | T_YMM, false, true, 2 },
157
158 { 0xF1, "psllw", T_0F | T_66 | T_YMM | T_EVEX | T_N16, false, true, 2 },
159 { 0xF2, "pslld", T_0F | T_66 | T_YMM | T_EVEX | T_EW0 | T_N16, false, true, 2 },
160 { 0xF3, "psllq", T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_N16, false, true, 2 },
161
162 { 0xE1, "psraw", T_0F | T_66 | T_YMM | T_EVEX | T_N16, false, true, 2 },
163 { 0xE2, "psrad", T_0F | T_66 | T_YMM | T_EVEX | T_EW0 | T_N16, false, true, 2 },
164 { 0xD1, "psrlw", T_0F | T_66 | T_YMM | T_EVEX | T_N16, false, true, 2 },
165 { 0xD2, "psrld", T_0F | T_66 | T_YMM | T_EVEX | T_EW0 | T_N16, false, true, 2 },
166 { 0xD3, "psrlq", T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_N16, false, true, 2 },
167
168 { 0xF8, "psubb", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
169 { 0xF9, "psubw", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
170 { 0xFA, "psubd", T_0F | T_66 | T_YMM | T_EVEX | T_EW0 | T_B32, false, true, 2 },
171 { 0xFB, "psubq", T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_B64, false, true, 2 },
172
173 { 0xE8, "psubsb", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
174 { 0xE9, "psubsw", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
175
176 { 0xD8, "psubusb", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
177 { 0xD9, "psubusw", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
178
179 { 0x68, "punpckhbw", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
180 { 0x69, "punpckhwd", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
181 { 0x6A, "punpckhdq", T_0F | T_66 | T_YMM | T_EVEX | T_EW0 | T_B32, false, true, 2 },
182 { 0x6D, "punpckhqdq", T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_B64, false, true, 2 },
183
184 { 0x60, "punpcklbw", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
185 { 0x61, "punpcklwd", T_0F | T_66 | T_YMM | T_EVEX, false, true, 2 },
186 { 0x62, "punpckldq", T_0F | T_66 | T_YMM | T_EVEX | T_EW0 | T_B32, false, true, 2 },
187 { 0x6C, "punpcklqdq", T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_B64, false, true, 2 },
188
189 { 0xEF, "pxor", T_0F | T_66 | T_YMM, false, true, 2 },
190
191 { 0x53, "rcpss", T_0F | T_F3, false, true, 2 },
192 { 0x52, "rsqrtss", T_0F | T_F3, false, true, 2 },
193
194 { 0xC6, "shufpd", T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_B64, true, true, 2 },
195 { 0xC6, "shufps", T_0F | T_YMM | T_EVEX | T_EW0 | T_B32, true, true, 2 },
196
197 { 0x51, "sqrtsd", T_0F | T_F2 | T_EVEX | T_EW1 | T_ER_X | T_N8, false, true, 2 },
198 { 0x51, "sqrtss", T_0F | T_F3 | T_EVEX | T_EW0 | T_ER_X | T_N4, false, true, 2 },
199
200 { 0x15, "unpckhpd", T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_B64, false, true, 2 },
201 { 0x15, "unpckhps", T_0F | T_YMM | T_EVEX | T_EW0 | T_B32, false, true, 2 },
202
203 { 0x14, "unpcklpd", T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_B64, false, true, 2 },
204 { 0x14, "unpcklps", T_0F | T_YMM | T_EVEX | T_EW0 | T_B32, false, true, 2 },
205
206 { 0xCF, "gf2p8affineinvqb", T_66 | T_0F3A | T_W1 | T_EVEX | T_YMM | T_EW1 | T_SAE_Z | T_B64, true, false, 3 },
207 { 0xCE, "gf2p8affineqb", T_66 | T_0F3A | T_W1 | T_EVEX | T_YMM | T_EW1 | T_SAE_Z | T_B64, true, false, 3 },
208 { 0xCF, "gf2p8mulb", T_66 | T_0F38 | T_W0 | T_EVEX | T_YMM | T_EW0 | T_SAE_Z, false, false, 3 },
209 };
210 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
211 const Tbl *p = &tbl[i];
212 std::string type = type2String(p->type);
213 if (omitOnly) {
214 if (p->enableOmit) {
215 printf("void v%s(const Xmm& x, const Operand& op%s) { v%s(x, x, op%s); }\n", p->name, p->hasIMM ? ", uint8 imm" : "", p->name, p->hasIMM ? ", imm" : "");
216 }
217 } else {
218 if (p->mode & 1) {
219 if (p->hasIMM) {
220 printf("void %s(const Xmm& xmm, const Operand& op, int imm) { opGen(xmm, op, 0x%02X, 0x66, isXMM_XMMorMEM, static_cast<uint8>(imm), 0x3A); }\n", p->name, p->code);
221 } else {
222 printf("void %s(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x%02X, 0x66, isXMM_XMMorMEM, NONE, 0x38); }\n", p->name, p->code);
223 }
224 }
225 if (p->mode & 2) {
226 printf("void v%s(const Xmm& x1, const Xmm& x2, const Operand& op%s) { opAVX_X_X_XM(x1, x2, op, %s, 0x%02X%s); }\n"
227 , p->name, p->hasIMM ? ", uint8 imm" : "", type.c_str(), p->code, p->hasIMM ? ", imm" : "");
228 }
229 }
230 }
231 }
232 }
233
putMemOp(const char * name,uint8 prefix,uint8 ext,uint8 code1,int code2,int bit=32)234 void putMemOp(const char *name, uint8 prefix, uint8 ext, uint8 code1, int code2, int bit = 32)
235 {
236 printf("void %s(const Address& addr) { ", name);
237 if (prefix) printf("db(0x%02X); ", prefix);
238 printf("opModM(addr, Reg%d(%d), 0x%02X, 0x%02X); }\n", bit, ext, code1, code2);
239 }
240
putLoadSeg(const char * name,uint8 code1,int code2=NONE)241 void putLoadSeg(const char *name, uint8 code1, int code2 = NONE)
242 {
243 printf("void %s(const Reg& reg, const Address& addr) { opLoadSeg(addr, reg, 0x%02X, 0x%02X); }\n", name, code1, code2);
244 }
245
put()246 void put()
247 {
248 const int NO = CodeGenerator::NONE;
249 {
250 char buf[16];
251 unsigned int v = VERSION;
252 if (v & 0xF) {
253 snprintf(buf, sizeof(buf), "%d.%02X%x", v >> 12, (v >> 4) & 0xFF, v & 0xF);
254 } else {
255 snprintf(buf, sizeof(buf), "%d.%02X", v >> 12, (v >> 4) & 0xFF);
256 }
257 printf("const char *getVersionString() const { return \"%s\"; }\n", buf);
258 }
259 const int B = 1 << 0;
260 const int W = 1 << 1;
261 const int D = 1 << 2;
262 const int Q = 1 << 3;
263 {
264 const struct Tbl {
265 uint8 code;
266 const char *name;
267 } tbl[] = {
268 // MMX
269 { 0x6B, "packssdw" },
270 { 0x63, "packsswb" },
271 { 0x67, "packuswb" },
272
273 { 0xDB, "pand" },
274 { 0xDF, "pandn" },
275
276 { 0xF5, "pmaddwd" },
277 { 0xE4, "pmulhuw" },
278 { 0xE5, "pmulhw" },
279 { 0xD5, "pmullw" },
280
281 { 0xEB, "por" },
282
283 { 0x68, "punpckhbw" },
284 { 0x69, "punpckhwd" },
285 { 0x6A, "punpckhdq" },
286
287 { 0x60, "punpcklbw" },
288 { 0x61, "punpcklwd" },
289 { 0x62, "punpckldq" },
290
291 { 0xEF, "pxor" },
292
293 // MMX2
294 { 0xE0, "pavgb" },
295 { 0xE3, "pavgw" },
296 { 0xEE, "pmaxsw" },
297 { 0xDE, "pmaxub" },
298 { 0xEA, "pminsw" },
299 { 0xDA, "pminub" },
300 { 0xF6, "psadbw" },
301 //
302 { 0xD4, "paddq" },
303 { 0xF4, "pmuludq" },
304 { 0xFB, "psubq" },
305 };
306 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
307 const Tbl *p = &tbl[i];
308 printf("void %s(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x%02X); }\n"
309 , p->name, p->code);
310 }
311 }
312
313 {
314 const struct Tbl {
315 uint8 code;
316 int mode;
317 const char *name;
318 } tbl[] = {
319 { 0xFC, B|W|D, "padd" },
320 { 0xEC, B|W , "padds" },
321 { 0xDC, B|W , "paddus" },
322 { 0x74, B|W|D, "pcmpeq" },
323 { 0x64, B|W|D, "pcmpgt" },
324 { 0xF0, W|D|Q, "psll" },
325 { 0xE0, W|D , "psra" },
326 { 0xD0, W|D|Q, "psrl" },
327 { 0xF8, B|W|D, "psub" },
328 { 0xE8, B|W , "psubs" },
329 { 0xD8, B|W , "psubus" },
330 };
331 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
332 const Tbl *p = &tbl[i];
333 static const char modTbl[][4] = {
334 "b", "w", "d", "q"
335 };
336 for (int j = 0; j < 4; j++) {
337 // B(0), W(1), D(2), Q(3)
338 if (!(p->mode & (1 << j))) continue;
339 printf("void %s%s(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x%02X); }\n"
340 , p->name, modTbl[j]
341 , p->code | j
342 );
343 }
344 }
345 }
346
347 {
348 const struct Tbl {
349 uint8 code;
350 int ext;
351 int mode;
352 const char *name;
353 } tbl[] = {
354 { 0x70, 6, W|D|Q, "psll" },
355 { 0x70, 4, W|D , "psra" },
356 { 0x70, 2, W|D|Q, "psrl" },
357 };
358 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
359 const Tbl *p = &tbl[i];
360 static const char modTbl[][4] = {
361 "b", "w", "d", "q"
362 };
363 for (int j = 0; j < 4; j++) {
364 // B(0), W(1), D(2), Q(3)
365 if (!(p->mode & (1 << j))) continue;
366 printf("void %s%s(const Mmx& mmx, int imm8) { opMMX_IMM(mmx, imm8, 0x%02X, %d); }\n"
367 , p->name, modTbl[j]
368 , p->code | j
369 , p->ext
370 );
371 }
372 }
373 printf("void pslldq(const Xmm& xmm, int imm8) { opMMX_IMM(xmm, imm8, 0x%02X, %d); }\n", 0x73, 7);
374 printf("void psrldq(const Xmm& xmm, int imm8) { opMMX_IMM(xmm, imm8, 0x%02X, %d); }\n", 0x73, 3);
375 }
376
377 {
378 const struct Tbl {
379 uint8 code;
380 uint8 pref;
381 const char *name;
382 } tbl[] = {
383 { 0x70, 0, "pshufw" },
384 { 0x70, 0xF2, "pshuflw" },
385 { 0x70, 0xF3, "pshufhw" },
386 { 0x70, 0x66, "pshufd" },
387 };
388 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
389 const Tbl *p = &tbl[i];
390 printf("void %s(const Mmx& mmx, const Operand& op, uint8 imm8) { opMMX(mmx, op, 0x%02X, 0x%02X, imm8); }\n", p->name, p->code, p->pref);
391 }
392 }
393 {
394 const struct MmxTbl6 {
395 uint8 code; // for (reg, reg/[mem])
396 uint8 code2; // for ([mem], reg)
397 int pref;
398 const char *name;
399 } mmxTbl6[] = {
400 { 0x6F, 0x7F, 0x66, "movdqa" },
401 { 0x6F, 0x7F, 0xF3, "movdqu" },
402 // SSE2
403 { 0x28, 0x29, NO, "movaps" },
404 { 0x10, 0x11, 0xF3, "movss" },
405 { 0x10, 0x11, NO, "movups" },
406 { 0x28, 0x29, 0x66, "movapd" },
407 { 0x10, 0x11, 0xF2, "movsd" },
408 { 0x10, 0x11, 0x66, "movupd" },
409 };
410 for (size_t i = 0; i < NUM_OF_ARRAY(mmxTbl6); i++) {
411 const MmxTbl6 *p = &mmxTbl6[i];
412 printf("void %s(const Xmm& xmm, const Operand& op) { opMMX(xmm, op, 0x%02X, 0x%02X); }\n", p->name, p->code, p->pref);
413 printf("void %s(const Address& addr, const Xmm& xmm) { ", p->name);
414 if (p->pref != NO) printf("db(0x%02X); ", p->pref);
415 printf("opModM(addr, xmm, 0x0F, 0x%02X); }\n", p->code2);
416 }
417 }
418 {
419 enum {
420 PS = 1 << 0,
421 SS = 1 << 1,
422 PD = 1 << 2,
423 SD = 1 << 3
424 };
425 const struct {
426 int code;
427 const char *name;
428 } sufTbl[] = {
429 { NO, "ps" },
430 { 0xF3, "ss" },
431 { 0x66, "pd" },
432 { 0xF2, "sd" },
433 };
434 const struct Tbl {
435 uint8 code;
436 int mode;
437 const char *name;
438 bool hasImm;
439 } tbl[] = {
440 { 0x58, PS|SS|PD|SD, "add" },
441 { 0x55, PS|PD , "andn" },
442 { 0x54, PS|PD , "and" },
443 { 0xC2, PS|SS|PD|SD, "cmp", true },
444 { 0x5E, PS|SS|PD|SD, "div" },
445 { 0x5F, PS|SS|PD|SD, "max" },
446 { 0x5D, PS|SS|PD|SD, "min" },
447 { 0x59, PS|SS|PD|SD, "mul" },
448 { 0x56, PS|PD , "or" },
449 { 0x53, PS|SS , "rcp" },
450 { 0x52, PS|SS , "rsqrt" },
451 { 0xC6, PS|PD , "shuf", true },
452 { 0x51, PS|SS|PD|SD, "sqrt" },
453 { 0x5C, PS|SS|PD|SD, "sub" },
454 { 0x15, PS|PD , "unpckh" },
455 { 0x14, PS|PD , "unpckl" },
456 { 0x57, PS|PD , "xor" },
457 //
458 };
459 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
460 const Tbl *p = &tbl[i];
461 for (size_t j = 0; j < NUM_OF_ARRAY(sufTbl); j++) {
462 if (!(p->mode & (1 << j))) continue;
463 if (p->hasImm) {
464 // don't change uint8 to int because NO is not in byte
465 printf("void %s%s(const Xmm& xmm, const Operand& op, uint8 imm8) { opGen(xmm, op, 0x%2X, 0x%02X, isXMM_XMMorMEM, imm8); }\n", p->name, sufTbl[j].name, p->code, sufTbl[j].code);
466 } else {
467 printf("void %s%s(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x%2X, 0x%02X, isXMM_XMMorMEM); }\n", p->name, sufTbl[j].name, p->code, sufTbl[j].code);
468 }
469 }
470 }
471 }
472 {
473 // (XMM, XMM)
474 const struct Tbl {
475 uint8 code;
476 uint8 pref;
477 const char *name;
478 } tbl[] = {
479 { 0xF7, 0x66, "maskmovdqu" },
480 { 0x12, 0 , "movhlps" },
481 { 0x16, 0 , "movlhps" },
482 };
483 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
484 const Tbl *p = &tbl[i];
485 printf("void %s(const Xmm& reg1, const Xmm& reg2) { ", p->name);
486 if (p->pref) printf("db(0x%02X); ", p->pref);
487 printf(" opModR(reg1, reg2, 0x0F, 0x%02X); }\n", p->code);
488 }
489 }
490 {
491 // (XMM, XMM|MEM)
492 const struct Tbl {
493 uint8 code;
494 int pref;
495 const char *name;
496 } tbl[] = {
497 { 0x6D, 0x66, "punpckhqdq" },
498 { 0x6C, 0x66, "punpcklqdq" },
499
500 { 0x2F, NO , "comiss" },
501 { 0x2E, NO , "ucomiss" },
502 { 0x2F, 0x66, "comisd" },
503 { 0x2E, 0x66, "ucomisd" },
504
505 { 0x5A, 0x66, "cvtpd2ps" },
506 { 0x5A, NO , "cvtps2pd" },
507 { 0x5A, 0xF2, "cvtsd2ss" },
508 { 0x5A, 0xF3, "cvtss2sd" },
509 { 0xE6, 0xF2, "cvtpd2dq" },
510 { 0xE6, 0x66, "cvttpd2dq" },
511 { 0xE6, 0xF3, "cvtdq2pd" },
512 { 0x5B, 0x66, "cvtps2dq" },
513 { 0x5B, 0xF3, "cvttps2dq" },
514 { 0x5B, NO , "cvtdq2ps" },
515 };
516 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
517 const Tbl *p = &tbl[i];
518 printf("void %s(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x%02X, 0x%02X, isXMM_XMMorMEM); }\n", p->name, p->code, p->pref);
519 }
520 }
521
522 {
523 // special type
524 const struct Tbl {
525 uint8 code;
526 int pref;
527 const char *name;
528 const char *cond;
529 } tbl[] = {
530 { 0x2A, NO , "cvtpi2ps", "isXMM_MMXorMEM" },
531 { 0x2D, NO , "cvtps2pi", "isMMX_XMMorMEM" },
532 { 0x2A, 0xF3, "cvtsi2ss", "isXMM_REG32orMEM" },
533 { 0x2D, 0xF3, "cvtss2si", "isREG32_XMMorMEM" },
534 { 0x2C, NO , "cvttps2pi", "isMMX_XMMorMEM" },
535 { 0x2C, 0xF3, "cvttss2si", "isREG32_XMMorMEM" },
536 { 0x2A, 0x66, "cvtpi2pd", "isXMM_MMXorMEM" },
537 { 0x2D, 0x66, "cvtpd2pi", "isMMX_XMMorMEM" },
538 { 0x2A, 0xF2, "cvtsi2sd", "isXMM_REG32orMEM" },
539 { 0x2D, 0xF2, "cvtsd2si", "isREG32_XMMorMEM" },
540 { 0x2C, 0x66, "cvttpd2pi", "isMMX_XMMorMEM" },
541 { 0x2C, 0xF2, "cvttsd2si", "isREG32_XMMorMEM" },
542 };
543 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
544 const Tbl *p = &tbl[i];
545 printf("void %s(const Operand& reg, const Operand& op) { opGen(reg, op, 0x%02X, 0x%02X, %s); }\n", p->name, p->code, p->pref, p->cond);
546 }
547 }
548 {
549 // prefetch
550 const struct Tbl {
551 int ext;
552 const char *name;
553 int code;
554 } tbl[] = {
555 { 1, "t0", 0x18},
556 { 2, "t1", 0x18},
557 { 3, "t2", 0x18},
558 { 0, "nta", 0x18},
559 { 2, "wt1", 0x0D},
560 { 1, "w", 0x0D},
561 };
562 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
563 const Tbl *p = &tbl[i];
564 printf("void prefetch%s(const Address& addr) { opModM(addr, Reg32(%d), 0x0F, 0x%02X); }\n", p->name, p->ext, p->code);
565 }
566 }
567 {
568 const struct Tbl {
569 uint8 code;
570 int pref;
571 const char *name;
572 } tbl[] = {
573 { 0x16, NO, "movhps" },
574 { 0x12, NO, "movlps" },
575 { 0x16, 0x66, "movhpd" },
576 { 0x12, 0x66, "movlpd" },
577 };
578 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
579 const Tbl *p = &tbl[i];
580 printf("void %s(const Operand& op1, const Operand& op2) { opMovXMM(op1, op2, 0x%02X, 0x%02X); }\n", p->name, p->code, p->pref);
581 }
582 }
583 {
584 // cmov
585 const struct Tbl {
586 uint8 ext;
587 const char *name;
588 } tbl[] = {
589 { 0, "o" },
590 { 1, "no" },
591 { 2, "b" },
592 { 2, "c" },
593 { 2, "nae" },
594 { 3, "nb" },
595 { 3, "ae" },
596 { 3, "nc" },
597 { 4, "e" },
598 { 4, "z" },
599 { 5, "ne" },
600 { 5, "nz" },
601 { 6, "be" },
602 { 6, "na" },
603 { 7, "nbe" },
604 { 7, "a" },
605 { 8, "s" },
606 { 9, "ns" },
607 { 10, "p" },
608 { 10, "pe" },
609 { 11, "np" },
610 { 11, "po" },
611 { 12, "l" },
612 { 12, "nge" },
613 { 13, "nl" },
614 { 13, "ge" },
615 { 14, "le" },
616 { 14, "ng" },
617 { 15, "nle" },
618 { 15, "g" },
619 };
620 const char *msg = "//-V524"; // disable warning of PVS-Studio
621 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
622 const Tbl *p = &tbl[i];
623 printf("void cmov%s(const Reg& reg, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x40 | %d); }%s\n", p->name, p->ext, msg);
624 printf("void j%s(std::string label, LabelType type = T_AUTO) { opJmp(label, type, 0x%02X, 0x%02X, 0x%02X); }%s\n", p->name, p->ext | 0x70, p->ext | 0x80, 0x0F, msg);
625 printf("void j%s(const Label& label, LabelType type = T_AUTO) { opJmp(label, type, 0x%02X, 0x%02X, 0x%02X); }%s\n", p->name, p->ext | 0x70, p->ext | 0x80, 0x0F, msg);
626 printf("void j%s(const char *label, LabelType type = T_AUTO) { j%s(std::string(label), type); }%s\n", p->name, p->name, msg);
627 printf("void j%s(const void *addr) { opJmpAbs(addr, T_NEAR, 0x%02X, 0x%02X, 0x%02X); }%s\n", p->name, p->ext | 0x70, p->ext | 0x80, 0x0F, msg);
628 printf("void set%s(const Operand& op) { opR_ModM(op, 8, 0, 0x0F, 0x90 | %d); }%s\n", p->name, p->ext, msg);
629 }
630 }
631 {
632 const struct Tbl {
633 const char *name;
634 uint8 code;
635 } tbl[] = {
636 { "loop", 0xE2 },
637 { "loope", 0xE1 },
638 { "loopne", 0xE0 },
639 };
640 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
641 const Tbl *p = &tbl[i];
642 printf("void %s(std::string label) { opJmp(label, T_SHORT, 0x%02X, 0, 0); }\n", p->name, p->code);
643 printf("void %s(const Label& label) { opJmp(label, T_SHORT, 0x%02X, 0, 0); }\n", p->name, p->code);
644 printf("void %s(const char *label) { %s(std::string(label)); }\n", p->name, p->name);
645 }
646 }
647 ////////////////////////////////////////////////////////////////
648 {
649 const GenericTbl tbl[] = {
650 { "bnd", 0xf2 }, /* 0xf2 prefix for MPX */
651 { "cbw", 0x66, 0x98 },
652 { "cdq", 0x99 },
653 { "clc", 0xF8 },
654 { "cld", 0xFC },
655 { "cli", 0xFA },
656 { "cmc", 0xF5 },
657
658 { "cpuid", 0x0F, 0xA2 },
659 { "cwd", 0x66, 0x99 },
660 { "cwde", 0x98 },
661 { "cmpsb", 0xA6 },
662 { "cmpsw", 0x66, 0xA7 },
663 { "cmpsd", 0xA7 },
664 { "int3", 0xCC },
665 { "scasb", 0xAE },
666 { "scasw", 0x66, 0xAF },
667 { "scasd", 0xAF },
668 { "movsb", 0xA4 },
669 { "leave", 0xC9 },
670 { "lodsb", 0xAC },
671 { "lodsw", 0x66, 0xAD },
672 { "lodsd", 0xAD },
673 { "movsw", 0x66, 0xA5 },
674 { "movsd", 0xA5 },
675 { "outsb", 0x6E },
676 { "outsw", 0x66, 0x6F },
677 { "outsd", 0x6F },
678 { "stosb", 0xAA },
679 { "stosw", 0x66, 0xAB },
680 { "stosd", 0xAB },
681 { "rep", 0xF3 },
682 { "repe", 0xF3 },
683 { "repz", 0xF3 },
684 { "repne", 0xF2 },
685 { "repnz", 0xF2 },
686
687 { "lahf", 0x9F },
688 { "lock", 0xF0 },
689
690 { "sahf", 0x9E },
691 { "stc", 0xF9 },
692 { "std", 0xFD },
693 { "sti", 0xFB },
694 { "sysenter", 0x0F, 0x34 },
695 { "sysexit", 0x0F, 0x35 },
696
697 { "emms", 0x0F, 0x77 },
698 { "pause", 0xF3, 0x90 },
699 { "sfence", 0x0F, 0xAE, 0xF8 },
700 { "lfence", 0x0F, 0xAE, 0xE8 },
701 { "mfence", 0x0F, 0xAE, 0xF0 },
702 { "monitor", 0x0F, 0x01, 0xC8 },
703 { "mwait", 0x0F, 0x01, 0xC9 },
704
705 { "rdmsr", 0x0F, 0x32 },
706 { "rdpmc", 0x0F, 0x33 },
707 { "rdtsc", 0x0F, 0x31 },
708 { "rdtscp", 0x0F, 0x01, 0xF9 },
709 { "ud2", 0x0F, 0x0B },
710 { "wait", 0x9B },
711 { "fwait", 0x9B },
712 { "wbinvd", 0x0F, 0x09 },
713 { "wrmsr", 0x0F, 0x30 },
714 { "xlatb", 0xD7 },
715
716 { "popf", 0x9D },
717 { "pushf", 0x9C },
718 { "stac", 0x0F, 0x01, 0xCB },
719
720 { "vzeroall", 0xC5, 0xFC, 0x77 },
721 { "vzeroupper", 0xC5, 0xF8, 0x77 },
722 { "xgetbv", 0x0F, 0x01, 0xD0 },
723
724 // FPU
725 { "f2xm1", 0xD9, 0xF0 },
726 { "fabs", 0xD9, 0xE1 },
727 { "faddp", 0xDE, 0xC1 },
728 { "fchs", 0xD9, 0xE0 },
729 { "fclex", 0x9B, 0xDB, 0xE2 },
730 { "fnclex", 0xDB, 0xE2 },
731 { "fcom", 0xD8, 0xD1 },
732 { "fcomp", 0xD8, 0xD9 },
733 { "fcompp", 0xDE, 0xD9 },
734 { "fcos", 0xD9, 0xFF },
735 { "fdecstp", 0xD9, 0xF6 },
736 { "fdivp", 0xDE, 0xF9 },
737 { "fdivrp", 0xDE, 0xF1 },
738 { "fincstp", 0xD9, 0xF7 },
739 { "finit", 0x9B, 0xDB, 0xE3 },
740 { "fninit", 0xDB, 0xE3 },
741 { "fld1", 0xD9, 0xE8 },
742 { "fldl2t", 0xD9, 0xE9 },
743 { "fldl2e", 0xD9, 0xEA },
744 { "fldpi", 0xD9, 0xEB },
745 { "fldlg2", 0xD9, 0xEC },
746 { "fldln2", 0xD9, 0xED },
747 { "fldz", 0xD9, 0xEE },
748 { "fmulp", 0xDE, 0xC9 },
749 { "fnop", 0xD9, 0xD0 },
750 { "fpatan", 0xD9, 0xF3 },
751 { "fprem", 0xD9, 0xF8 },
752 { "fprem1", 0xD9, 0xF5 },
753 { "fptan", 0xD9, 0xF2 },
754 { "frndint", 0xD9, 0xFC },
755 { "fscale", 0xD9, 0xFD },
756 { "fsin", 0xD9, 0xFE },
757 { "fsincos", 0xD9, 0xFB },
758 { "fsqrt", 0xD9, 0xFA },
759 { "fsubp", 0xDE, 0xE9 },
760 { "fsubrp", 0xDE, 0xE1 },
761 { "ftst", 0xD9, 0xE4 },
762 { "fucom", 0xDD, 0xE1 },
763 { "fucomp", 0xDD, 0xE9 },
764 { "fucompp", 0xDA, 0xE9 },
765 { "fxam", 0xD9, 0xE5 },
766 { "fxch", 0xD9, 0xC9 },
767 { "fxtract", 0xD9, 0xF4 },
768 { "fyl2x", 0xD9, 0xF1 },
769 { "fyl2xp1", 0xD9, 0xF9 },
770
771 // AMD Zen
772 { "monitorx", 0x0F, 0x01, 0xFA },
773 { "mwaitx", 0x0F, 0x01, 0xFB },
774 { "clzero", 0x0F, 0x01, 0xFC },
775 };
776 putGeneric(tbl, NUM_OF_ARRAY(tbl));
777 puts("void enter(uint16 x, uint8 y) { db(0xC8); dw(x); db(y); }");
778 puts("void int_(uint8 x) { db(0xCD); db(x); }");
779 putLoadSeg("lss", 0x0F, 0xB2);
780 putLoadSeg("lfs", 0x0F, 0xB4);
781 putLoadSeg("lgs", 0x0F, 0xB5);
782 }
783 {
784 const struct Tbl {
785 uint8 code; // (reg, reg)
786 uint8 ext; // (reg, imm)
787 const char *name;
788 } tbl[] = {
789 { 0x10, 2, "adc" },
790 { 0x00, 0, "add" },
791 { 0x20, 4, "and_" },
792 { 0x38, 7, "cmp" },
793 { 0x08, 1, "or_" },
794 { 0x18, 3, "sbb" },
795 { 0x28, 5, "sub" },
796 { 0x30, 6, "xor_" },
797 };
798 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
799 const Tbl *p = &tbl[i];
800 printf("void %s(const Operand& op1, const Operand& op2) { opRM_RM(op1, op2, 0x%02X); }\n", p->name, p->code);
801 printf("void %s(const Operand& op, uint32 imm) { opRM_I(op, imm, 0x%02X, %d); }\n", p->name, p->code, p->ext);
802 }
803 }
804
805 {
806 const struct Tbl {
807 uint8 code;
808 uint8 ext;
809 const char *name;
810 } tbl[] = {
811 { 0x48, 1, "dec" },
812 { 0x40, 0, "inc" },
813 };
814 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
815 const Tbl *p = &tbl[i];
816 printf("void %s(const Operand& op) { opIncDec(op, 0x%02X, %d); }\n", p->name, p->code, p->ext);
817 }
818 }
819 {
820 const struct Tbl {
821 uint8 code;
822 uint8 ext;
823 const char *name;
824 } tbl[] = {
825 { 0xa3, 4, "bt" },
826 { 0xab, 5, "bts" },
827 { 0xb3, 6, "btr" },
828 { 0xbb, 7, "btc" },
829 };
830 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
831 const Tbl *p = &tbl[i];
832 printf("void %s(const Operand& op, const Reg& reg) { opModRM(reg, op, op.isREG(16|32|64) && op.getBit() == reg.getBit(), op.isMEM(), 0x0f, 0x%02X); }\n", p->name, p->code);
833 printf("void %s(const Operand& op, uint8 imm) { opR_ModM(op, 16|32|64, %d, 0x0f, 0xba, NONE, false, 1); db(imm); }\n", p->name, p->ext);
834 }
835 }
836 {
837 const struct Tbl {
838 uint8 code;
839 uint8 ext;
840 const char *name;
841 } tbl[] = {
842 { 0xF6, 6, "div" },
843 { 0xF6, 7, "idiv" },
844 { 0xF6, 5, "imul" },
845 { 0xF6, 4, "mul" },
846 { 0xF6, 3, "neg" },
847 { 0xF6, 2, "not_" },
848 };
849 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
850 const Tbl *p = &tbl[i];
851 const std::string name = p->name;
852 printf("void %s(const Operand& op) { opR_ModM(op, 0, %d, 0x%02X); }\n", p->name, p->ext, p->code);
853 }
854 }
855 {
856 const struct Tbl {
857 const char *name;
858 uint8 ext;
859 } tbl[] = {
860 { "rcl", 2 },
861 { "rcr", 3 },
862 { "rol", 0 },
863 { "ror", 1 },
864 { "sar", 7 },
865 { "shl", 4 },
866 { "shr", 5 },
867
868 { "sal", 4 },
869 };
870 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
871 const Tbl *p = &tbl[i];
872 printf("void %s(const Operand& op, int imm) { opShift(op, imm, %d); }\n", p->name, p->ext);
873 printf("void %s(const Operand& op, const Reg8& _cl) { opShift(op, _cl, %d); }\n", p->name, p->ext);
874 }
875 }
876 {
877 const struct Tbl {
878 const char *name;
879 uint8 code;
880 } tbl[] = {
881 { "shld", 0xA4 },
882 { "shrd", 0xAC },
883 };
884 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
885 const Tbl *p = &tbl[i];
886 printf("void %s(const Operand& op, const Reg& reg, uint8 imm) { opShxd(op, reg, imm, 0x%02X); }\n", p->name, p->code);
887 printf("void %s(const Operand& op, const Reg& reg, const Reg8& _cl) { opShxd(op, reg, 0, 0x%02X, &_cl); }\n", p->name, p->code);
888 }
889 }
890 {
891 const struct Tbl {
892 const char *name;
893 uint8 code;
894 } tbl[] = {
895 { "bsf", 0xBC },
896 { "bsr", 0xBD },
897 };
898 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
899 const Tbl *p = &tbl[i];
900 printf("void %s(const Reg®, const Operand& op) { opModRM(reg, op, op.isREG(16 | i32e), op.isMEM(), 0x0F, 0x%02X); }\n", p->name, p->code);
901 }
902 }
903 {
904 const struct Tbl {
905 const char *name;
906 uint8 code;
907 } tbl[] = {
908 { "popcnt", 0xB8 },
909 { "tzcnt", 0xBC },
910 { "lzcnt", 0xBD },
911 };
912 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
913 const Tbl *p = &tbl[i];
914 printf("void %s(const Reg®, const Operand& op) { opSp1(reg, op, 0xF3, 0x0F, 0x%02X); }\n", p->name, p->code);
915 }
916 }
917 // SSSE3
918 {
919 const struct Tbl {
920 uint8 code;
921 const char *name;
922 } tbl[] = {
923 { 0x00, "pshufb" },
924 { 0x01, "phaddw" },
925 { 0x02, "phaddd" },
926 { 0x03, "phaddsw" },
927 { 0x04, "pmaddubsw" },
928 { 0x05, "phsubw" },
929 { 0x06, "phsubd" },
930 { 0x07, "phsubsw" },
931 { 0x08, "psignb" },
932 { 0x09, "psignw" },
933 { 0x0a, "psignd" },
934 { 0x0b, "pmulhrsw" },
935 { 0x1c, "pabsb" },
936 { 0x1d, "pabsw" },
937 { 0x1e, "pabsd" },
938 };
939 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
940 const Tbl *p = &tbl[i];
941 printf("void %s(const Mmx& mmx, const Operand& op) { opMMX(mmx, op, 0x%02X, 0x66, NONE, 0x38); }\n", p->name, p->code);
942 }
943 printf("void palignr(const Mmx& mmx, const Operand& op, int imm) { opMMX(mmx, op, 0x0f, 0x66, static_cast<uint8>(imm), 0x3a); }\n");
944 }
945 {
946 const struct Tbl {
947 const char *name;
948 uint8 code;
949 } tbl[] = {
950 { "pclmullqlqdq", 0 },
951 { "pclmulhqlqdq", 1 },
952 { "pclmullqhdq", 0x10 },
953 { "pclmulhqhdq", 0x11 },
954 };
955 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
956 const Tbl *p = &tbl[i];
957 printf("void %s(const Xmm& xmm, const Operand& op) { pclmulqdq(xmm, op, 0x%02X); }\n", p->name, p->code);
958 }
959 }
960 {
961 const struct Tbl {
962 uint8 code1;
963 int code2;
964 uint8 ext;
965 const char *name;
966 uint8 prefix;
967 } tbl[] = {
968 { 0x0F, 0xAE, 2, "ldmxcsr", 0 },
969 { 0x0F, 0xAE, 3, "stmxcsr", 0 },
970 { 0x0F, 0xAE, 7, "clflush", 0 },
971 { 0x0F, 0xAE, 7, "clflushopt", 0x66 },
972 { 0xDF, NONE, 4, "fbld", 0 },
973 { 0xDF, NONE, 6, "fbstp", 0 },
974 { 0xD9, NONE, 5, "fldcw", 0 },
975 { 0xD9, NONE, 4, "fldenv", 0 },
976 { 0xDD, NONE, 4, "frstor", 0 },
977 { 0xDD, NONE, 6, "fsave", 0x9B },
978 { 0xDD, NONE, 6, "fnsave", 0 },
979 { 0xD9, NONE, 7, "fstcw", 0x9B },
980 { 0xD9, NONE, 7, "fnstcw", 0 },
981 { 0xD9, NONE, 6, "fstenv", 0x9B },
982 { 0xD9, NONE, 6, "fnstenv", 0 },
983 { 0xDD, NONE, 7, "fstsw", 0x9B },
984 { 0xDD, NONE, 7, "fnstsw", 0 },
985 { 0x0F, 0xAE, 1, "fxrstor", 0 },
986 };
987 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
988 const Tbl *p = &tbl[i];
989 putMemOp(p->name, p->prefix, p->ext, p->code1, p->code2);
990 }
991 puts("void fstsw(const Reg16& r) { if (r.getIdx() != Operand::AX) XBYAK_THROW(ERR_BAD_PARAMETER) db(0x9B); db(0xDF); db(0xE0); }");
992 puts("void fnstsw(const Reg16& r) { if (r.getIdx() != Operand::AX) XBYAK_THROW(ERR_BAD_PARAMETER) db(0xDF); db(0xE0); }");
993 }
994 {
995 const struct Tbl {
996 uint8 code;
997 const char *name;
998 } tbl[] = {
999 { 0x2B, "movntpd" },
1000 { 0xE7, "movntdq" },
1001 };
1002 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1003 const Tbl *p = &tbl[i];
1004 // cast xmm register to 16bit register to put 0x66
1005 printf("void %s(const Address& addr, const Xmm& reg) { opModM(addr, Reg16(reg.getIdx()), 0x0F, 0x%02X); }\n", p->name, p->code);
1006 }
1007 }
1008 {
1009 const struct Tbl {
1010 uint8 code;
1011 const char *name;
1012 } tbl[] = {
1013 { 0xBE, "movsx" },
1014 { 0xB6, "movzx" },
1015 };
1016 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1017 const Tbl *p = &tbl[i];
1018 printf("void %s(const Reg& reg, const Operand& op) { opMovxx(reg, op, 0x%02X); }\n", p->name, p->code);
1019 }
1020 }
1021 { // in/out
1022 puts("void in_(const Reg& a, uint8 v) { opInOut(a, 0xE4, v); }");
1023 puts("void in_(const Reg& a, const Reg& d) { opInOut(a, d, 0xEC); }");
1024 puts("void out_(uint8 v, const Reg& a) { opInOut(a, 0xE6, v); }");
1025 puts("void out_(const Reg& d, const Reg& a) { opInOut(a, d, 0xEE); }");
1026 }
1027 // mpx
1028 {
1029 puts("void bndcl(const BoundsReg& bnd, const Operand& op) { db(0xF3); opR_ModM(op, i32e, bnd.getIdx(), 0x0F, 0x1A, NONE, !op.isMEM()); }");
1030 puts("void bndcu(const BoundsReg& bnd, const Operand& op) { db(0xF2); opR_ModM(op, i32e, bnd.getIdx(), 0x0F, 0x1A, NONE, !op.isMEM()); }");
1031 puts("void bndcn(const BoundsReg& bnd, const Operand& op) { db(0xF2); opR_ModM(op, i32e, bnd.getIdx(), 0x0F, 0x1B, NONE, !op.isMEM()); }");
1032 puts("void bndldx(const BoundsReg& bnd, const Address& addr) { opMIB(addr, bnd, 0x0F, 0x1A); }");
1033 puts("void bndmk(const BoundsReg& bnd, const Address& addr) { db(0xF3); opModM(addr, bnd, 0x0F, 0x1B); }");
1034 puts("void bndmov(const BoundsReg& bnd, const Operand& op) { db(0x66); opModRM(bnd, op, op.isBNDREG(), op.isMEM(), 0x0F, 0x1A); }");
1035 puts("void bndmov(const Address& addr, const BoundsReg& bnd) { db(0x66); opModM(addr, bnd, 0x0F, 0x1B); }");
1036 puts("void bndstx(const Address& addr, const BoundsReg& bnd) { opMIB(addr, bnd, 0x0F, 0x1B); }");
1037 }
1038 // misc
1039 {
1040 puts("void lea(const Reg& reg, const Address& addr) { if (!reg.isBit(16 | i32e)) XBYAK_THROW(ERR_BAD_SIZE_OF_REGISTER) opModM(addr, reg, 0x8D); }");
1041 puts("void bswap(const Reg32e& reg) { opModR(Reg32(1), reg, 0x0F); }");
1042 puts("void ret(int imm = 0) { if (imm) { db(0xC2); dw(imm); } else { db(0xC3); } }");
1043
1044 puts("void xadd(const Operand& op, const Reg& reg) { opModRM(reg, op, (op.isREG() && reg.isREG() && op.getBit() == reg.getBit()), op.isMEM(), 0x0F, 0xC0 | (reg.isBit(8) ? 0 : 1)); }");
1045 puts("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)); }");
1046 puts("void movbe(const Reg& reg, const Address& addr) { opModM(addr, reg, 0x0F, 0x38, 0xF0); }");
1047 puts("void movbe(const Address& addr, const Reg& reg) { opModM(addr, reg, 0x0F, 0x38, 0xF1); }");
1048 puts("void adcx(const Reg32e& reg, const Operand& op) { opGen(reg, op, 0xF6, 0x66, isREG32_REG32orMEM, NONE, 0x38); }");
1049 puts("void adox(const Reg32e& reg, const Operand& op) { opGen(reg, op, 0xF6, 0xF3, isREG32_REG32orMEM, NONE, 0x38); }");
1050 puts("void cmpxchg8b(const Address& addr) { opModM(addr, Reg32(1), 0x0F, 0xC7); }");
1051
1052 puts("void pextrw(const Operand& op, const Mmx& xmm, uint8 imm) { opExt(op, xmm, 0x15, imm, true); }");
1053 puts("void pextrb(const Operand& op, const Xmm& xmm, uint8 imm) { opExt(op, xmm, 0x14, imm); }");
1054 puts("void pextrd(const Operand& op, const Xmm& xmm, uint8 imm) { opExt(op, xmm, 0x16, imm); }");
1055 puts("void extractps(const Operand& op, const Xmm& xmm, uint8 imm) { opExt(op, xmm, 0x17, imm); }");
1056 puts("void pinsrw(const Mmx& mmx, const Operand& op, int imm) { if (!op.isREG(32) && !op.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opGen(mmx, op, 0xC4, mmx.isXMM() ? 0x66 : NONE, 0, imm); }");
1057 puts("void insertps(const Xmm& xmm, const Operand& op, uint8 imm) { opGen(xmm, op, 0x21, 0x66, isXMM_XMMorMEM, imm, 0x3A); }");
1058 puts("void pinsrb(const Xmm& xmm, const Operand& op, uint8 imm) { opGen(xmm, op, 0x20, 0x66, isXMM_REG32orMEM, imm, 0x3A); }");
1059 puts("void pinsrd(const Xmm& xmm, const Operand& op, uint8 imm) { opGen(xmm, op, 0x22, 0x66, isXMM_REG32orMEM, imm, 0x3A); }");
1060
1061 puts("void pmovmskb(const Reg32e& reg, const Mmx& mmx) { if (mmx.isXMM()) db(0x66); opModR(reg, mmx, 0x0F, 0xD7); }");
1062 puts("void maskmovq(const Mmx& reg1, const Mmx& reg2) { if (!reg1.isMMX() || !reg2.isMMX()) XBYAK_THROW(ERR_BAD_COMBINATION) opModR(reg1, reg2, 0x0F, 0xF7); }");
1063 puts("void movmskps(const Reg32e& reg, const Xmm& xmm) { opModR(reg, xmm, 0x0F, 0x50); }");
1064 puts("void movmskpd(const Reg32e& reg, const Xmm& xmm) { db(0x66); movmskps(reg, xmm); }");
1065 puts("void movntps(const Address& addr, const Xmm& xmm) { opModM(addr, Mmx(xmm.getIdx()), 0x0F, 0x2B); }");
1066 puts("void movntdqa(const Xmm& xmm, const Address& addr) { db(0x66); opModM(addr, xmm, 0x0F, 0x38, 0x2A); }");
1067 puts("void lddqu(const Xmm& xmm, const Address& addr) { db(0xF2); opModM(addr, xmm, 0x0F, 0xF0); }");
1068 puts("void movnti(const Address& addr, const Reg32e& reg) { opModM(addr, reg, 0x0F, 0xC3); }");
1069 puts("void movntq(const Address& addr, const Mmx& mmx) { if (!mmx.isMMX()) XBYAK_THROW(ERR_BAD_COMBINATION) opModM(addr, mmx, 0x0F, 0xE7); }");
1070
1071 puts("void movd(const Address& addr, const Mmx& mmx) { if (mmx.isXMM()) db(0x66); opModM(addr, mmx, 0x0F, 0x7E); }");
1072 puts("void movd(const Reg32& reg, const Mmx& mmx) { if (mmx.isXMM()) db(0x66); opModR(mmx, reg, 0x0F, 0x7E); }");
1073 puts("void movd(const Mmx& mmx, const Address& addr) { if (mmx.isXMM()) db(0x66); opModM(addr, mmx, 0x0F, 0x6E); }");
1074 puts("void movd(const Mmx& mmx, const Reg32& reg) { if (mmx.isXMM()) db(0x66); opModR(mmx, reg, 0x0F, 0x6E); }");
1075 puts("void movq2dq(const Xmm& xmm, const Mmx& mmx) { db(0xF3); opModR(xmm, mmx, 0x0F, 0xD6); }");
1076 puts("void movdq2q(const Mmx& mmx, const Xmm& xmm) { db(0xF2); opModR(mmx, xmm, 0x0F, 0xD6); }");
1077 puts("void movq(const Mmx& mmx, const Operand& op) { if (mmx.isXMM()) db(0xF3); opModRM(mmx, op, (mmx.getKind() == op.getKind()), op.isMEM(), 0x0F, mmx.isXMM() ? 0x7E : 0x6F); }");
1078 puts("void movq(const Address& addr, const Mmx& mmx) { if (mmx.isXMM()) db(0x66); opModM(addr, mmx, 0x0F, mmx.isXMM() ? 0xD6 : 0x7F); }");
1079 puts("void rdrand(const Reg& r) { if (r.isBit(8)) XBYAK_THROW(ERR_BAD_SIZE_OF_REGISTER) opModR(Reg(6, Operand::REG, r.getBit()), r, 0x0F, 0xC7); }");
1080 puts("void rdseed(const Reg& r) { if (r.isBit(8)) XBYAK_THROW(ERR_BAD_SIZE_OF_REGISTER) opModR(Reg(7, Operand::REG, r.getBit()), r, 0x0F, 0xC7); }");
1081 puts("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)); }");
1082 }
1083 {
1084 const struct Tbl {
1085 uint8 m16;
1086 uint8 m32;
1087 uint8 m64;
1088 uint8 ext;
1089 const char *name;
1090 uint8 m64ext;
1091 } tbl[] = {
1092 { 0x00, 0xD8, 0xDC, 0, "fadd" },
1093 { 0xDE, 0xDA, 0x00, 0, "fiadd" },
1094 { 0x00, 0xD8, 0xDC, 2, "fcom" },
1095 { 0x00, 0xD8, 0xDC, 3, "fcomp" },
1096 { 0x00, 0xD8, 0xDC, 6, "fdiv" },
1097 { 0xDE, 0xDA, 0x00, 6, "fidiv" },
1098 { 0x00, 0xD8, 0xDC, 7, "fdivr" },
1099 { 0xDE, 0xDA, 0x00, 7, "fidivr" },
1100 { 0xDE, 0xDA, 0x00, 2, "ficom" },
1101 { 0xDE, 0xDA, 0x00, 3, "ficomp" },
1102 { 0xDF, 0xDB, 0xDF, 0, "fild", 5 },
1103 { 0xDF, 0xDB, 0x00, 2, "fist" },
1104 { 0xDF, 0xDB, 0xDF, 3, "fistp", 7 },
1105 { 0xDF, 0xDB, 0xDD, 1, "fisttp" },
1106 { 0x00, 0xD9, 0xDD, 0, "fld" },
1107 { 0x00, 0xD8, 0xDC, 1, "fmul" },
1108 { 0xDE, 0xDA, 0x00, 1, "fimul" },
1109 { 0x00, 0xD9, 0xDD, 2, "fst" },
1110 { 0x00, 0xD9, 0xDD, 3, "fstp" },
1111 { 0x00, 0xD8, 0xDC, 4, "fsub" },
1112 { 0xDE, 0xDA, 0x00, 4, "fisub" },
1113 { 0x00, 0xD8, 0xDC, 5, "fsubr" },
1114 { 0xDE, 0xDA, 0x00, 5, "fisubr" },
1115 };
1116 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1117 const Tbl *p = &tbl[i];
1118 printf("void %s(const Address& addr) { opFpuMem(addr, 0x%02X, 0x%02X, 0x%02X, %d, %d); }\n", p->name, p->m16, p->m32, p->m64, p->ext, p->m64ext);
1119 }
1120 }
1121 {
1122 const struct Tbl {
1123 uint32 code1;
1124 uint32 code2;
1125 const char *name;
1126 } tbl[] = {
1127 { 0xD8C0, 0xDCC0, "fadd" },
1128 { 0x0000, 0xDEC0, "faddp" },
1129
1130 { 0xDAC0, 0x00C0, "fcmovb" },
1131 { 0xDAC8, 0x00C8, "fcmove" },
1132 { 0xDAD0, 0x00D0, "fcmovbe" },
1133 { 0xDAD8, 0x00D8, "fcmovu" },
1134 { 0xDBC0, 0x00C0, "fcmovnb" },
1135 { 0xDBC8, 0x00C8, "fcmovne" },
1136 { 0xDBD0, 0x00D0, "fcmovnbe" },
1137 { 0xDBD8, 0x00D8, "fcmovnu" },
1138
1139 { 0xDBF0, 0x00F0, "fcomi" },
1140 { 0xDFF0, 0x00F0, "fcomip" },
1141 { 0xDBE8, 0x00E8, "fucomi" },
1142 { 0xDFE8, 0x00E8, "fucomip" },
1143
1144 { 0xD8F0, 0xDCF8, "fdiv" },
1145 { 0x0000, 0xDEF8, "fdivp" },
1146 { 0xD8F8, 0xDCF0, "fdivr" },
1147 { 0x0000, 0xDEF0, "fdivrp" },
1148 { 0xD8C8, 0xDCC8, "fmul" },
1149 { 0x0000, 0xDEC8, "fmulp" },
1150 { 0xD8E0, 0xDCE8, "fsub" },
1151 { 0x0000, 0xDEE8, "fsubp" },
1152 { 0xD8E8, 0xDCE0, "fsubr" },
1153 { 0x0000, 0xDEE0, "fsubrp" },
1154 };
1155 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1156 const Tbl *p = &tbl[i];
1157 printf("void %s(const Fpu& reg1, const Fpu& reg2) { opFpuFpu(reg1, reg2, 0x%04X, 0x%04X); }\n", p->name, p->code1, p->code2);
1158 // omit st0 version(like nasm)
1159 if (p->code1) {
1160 printf("void %s(const Fpu& reg1) { opFpuFpu(st0, reg1, 0x%04X, 0x%04X); }\n", p->name, p->code1, p->code2);
1161 } else {
1162 printf("void %s(const Fpu& reg1) { opFpuFpu(reg1, st0, 0x%04X, 0x%04X); }\n", p->name, p->code1, p->code2);
1163 }
1164 }
1165 }
1166 {
1167 const struct Tbl {
1168 uint8 code1;
1169 uint8 code2;
1170 const char *name;
1171 } tbl[] = {
1172 { 0xD8, 0xD0, "fcom" },
1173 { 0xD8, 0xD8, "fcomp" },
1174 { 0xDD, 0xC0, "ffree" },
1175 { 0xD9, 0xC0, "fld" },
1176 { 0xDD, 0xD0, "fst" },
1177 { 0xDD, 0xD8, "fstp" },
1178 { 0xDD, 0xE0, "fucom" },
1179 { 0xDD, 0xE8, "fucomp" },
1180 { 0xD9, 0xC8, "fxch" },
1181 };
1182 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1183 const Tbl *p = &tbl[i];
1184 printf("void %s(const Fpu& reg) { opFpu(reg, 0x%02X, 0x%02X); }\n", p->name, p->code1, p->code2);
1185 }
1186 }
1187 // AVX
1188 { // pd, ps, sd, ss
1189 const struct Tbl {
1190 uint8 code;
1191 const char *name;
1192 bool only_pd_ps;
1193 } tbl[] = {
1194 { 0x58, "add", false },
1195 { 0x5C, "sub", false },
1196 { 0x59, "mul", false },
1197 { 0x5E, "div", false },
1198 { 0x5F, "max", false },
1199 { 0x5D, "min", false },
1200 { 0x54, "and", true },
1201 { 0x55, "andn", true },
1202 { 0x56, "or", true },
1203 { 0x57, "xor", true },
1204 };
1205 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1206 const Tbl *p = &tbl[i];
1207 printf("void v%spd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_66 | T_EW1 | T_YMM | T_EVEX | T_ER_Z | T_B64, 0x%02X); }\n", p->name, p->code);
1208 printf("void v%sps(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_EW0 | T_YMM | T_EVEX | T_ER_Z | T_B32, 0x%02X); }\n", p->name, p->code);
1209 if (p->only_pd_ps) continue;
1210 printf("void v%ssd(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F2 | T_EW1 | T_EVEX | T_ER_Z | T_N8, 0x%02X); }\n", p->name, p->code);
1211 printf("void v%sss(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, T_0F | T_F3 | T_EW0 | T_EVEX | T_ER_Z | T_N4, 0x%02X); }\n", p->name, p->code);
1212 }
1213 }
1214 putX_X_XM(false);
1215
1216 // (x, x/m[, imm]) or (y, y/m[, imm])
1217 {
1218 const struct Tbl {
1219 uint8 code;
1220 const char *name;
1221 int type;
1222 bool hasIMM;
1223 int mode; // 1 : SSE, 2 : AVX, 3 : SSE + AVX
1224 } tbl[] = {
1225 { 0x15, "blendvpd", T_0F38 | T_66, false, 1 },
1226 { 0x14, "blendvps", T_0F38 | T_66, false, 1 },
1227 { 0x10, "pblendvb", T_0F38 | T_66, false, 1 },
1228 { 0xDF, "aeskeygenassist", T_0F3A | T_66, true, 3 },
1229 { 0xDB, "aesimc", T_0F38 | T_66 | T_W0, false, 3 },
1230 { 0x09, "roundpd", T_0F3A | T_66 | T_YMM, true, 3 },
1231 { 0x08, "roundps", T_0F3A | T_66 | T_YMM, true, 3 },
1232 { 0x05, "permilpd", T_0F3A | T_66 | T_YMM | T_EVEX | T_EW1 | T_B64, true, 2 },
1233 { 0x04, "permilps", T_0F3A | T_66 | T_YMM | T_EVEX | T_EW0 | T_B32, true, 2 },
1234 { 0x61, "pcmpestri", T_0F3A | T_66, true, 3 },
1235 { 0x60, "pcmpestrm", T_0F3A | T_66, true, 3 },
1236 { 0x63, "pcmpistri", T_0F3A | T_66, true, 3 },
1237 { 0x62, "pcmpistrm", T_0F3A | T_66, true, 3 },
1238 { 0x0E, "testps", T_0F38 | T_66 | T_YMM, false, 2 },
1239 { 0x0F, "testpd", T_0F38 | T_66 | T_YMM, false, 2 },
1240 { 0x2F, "comisd", T_0F | T_66 | T_EVEX | T_EW1 | T_SAE_X | T_N8, false, 2 },
1241 { 0x2F, "comiss", T_0F | T_EVEX | T_EW0 | T_SAE_X | T_N4, false, 2 },
1242 { 0x5B, "cvtdq2ps", T_0F | T_YMM | T_EVEX | T_EW0 | T_B32 | T_ER_Z, false, 2 },
1243 { 0x5B, "cvtps2dq", T_0F | T_66 | T_YMM | T_EVEX | T_EW0 | T_B32 | T_ER_Z, false, 2 },
1244 { 0x5B, "cvttps2dq", T_0F | T_F3 | T_YMM | T_EVEX | T_EW0 | T_B32 | T_SAE_Z, false, 2 },
1245 { 0x28, "movapd", T_0F | T_66 | T_YMM | T_EVEX | T_EW1, false, 2 },
1246 { 0x28, "movaps", T_0F | T_YMM | T_EVEX | T_EW0, false, 2 },
1247 { 0x12, "movddup", T_0F | T_F2 | T_YMM | T_EVEX | T_EW1 | T_ER_X | T_ER_Y | T_ER_Z | T_DUP, false, 3 },
1248 { 0x6F, "movdqa", T_0F | T_66 | T_YMM, false, 2 },
1249 { 0x6F, "movdqu", T_0F | T_F3 | T_YMM, false, 2 },
1250 { 0x16, "movshdup", T_0F | T_F3 | T_YMM | T_EVEX | T_EW0, false, 3 },
1251 { 0x12, "movsldup", T_0F | T_F3 | T_YMM | T_EVEX | T_EW0, false, 3 },
1252 { 0x10, "movupd", T_0F | T_66 | T_YMM | T_EVEX | T_EW1, false, 2 },
1253 { 0x10, "movups", T_0F | T_YMM | T_EVEX | T_EW0, false, 2 },
1254
1255 { 0x1C, "pabsb", T_0F38 | T_66 | T_YMM | T_EVEX, false, 2 },
1256 { 0x1D, "pabsw", T_0F38 | T_66 | T_YMM | T_EVEX, false, 2 },
1257 { 0x1E, "pabsd", T_0F38 | T_66 | T_YMM | T_EVEX | T_EW0 | T_B32, false, 2 },
1258 { 0x41, "phminposuw", T_0F38 | T_66, false, 3 },
1259
1260 { 0x20, "pmovsxbw", T_0F38 | T_66 | T_YMM | T_EVEX | T_N8 | T_N_VL, false, 3 },
1261 { 0x21, "pmovsxbd", T_0F38 | T_66 | T_YMM | T_EVEX | T_N4 | T_N_VL, false, 3 },
1262 { 0x22, "pmovsxbq", T_0F38 | T_66 | T_YMM | T_EVEX | T_N2 | T_N_VL, false, 3 },
1263 { 0x23, "pmovsxwd", T_0F38 | T_66 | T_YMM | T_EVEX | T_N8 | T_N_VL, false, 3 },
1264 { 0x24, "pmovsxwq", T_0F38 | T_66 | T_YMM | T_EVEX | T_N4 | T_N_VL, false, 3 },
1265 { 0x25, "pmovsxdq", T_0F38 | T_66 | T_YMM | T_EVEX | T_EW0 | T_N8 | T_N_VL, false, 3 },
1266
1267 { 0x30, "pmovzxbw", T_0F38 | T_66 | T_YMM | T_EVEX | T_N8 | T_N_VL, false, 3 },
1268 { 0x31, "pmovzxbd", T_0F38 | T_66 | T_YMM | T_EVEX | T_N4 | T_N_VL, false, 3 },
1269 { 0x32, "pmovzxbq", T_0F38 | T_66 | T_YMM | T_EVEX | T_N2 | T_N_VL, false, 3 },
1270 { 0x33, "pmovzxwd", T_0F38 | T_66 | T_YMM | T_EVEX | T_N8 | T_N_VL, false, 3 },
1271 { 0x34, "pmovzxwq", T_0F38 | T_66 | T_YMM | T_EVEX | T_N4 | T_N_VL, false, 3 },
1272 { 0x35, "pmovzxdq", T_0F38 | T_66 | T_YMM | T_EVEX | T_EW0 | T_N8 | T_N_VL, false, 3 },
1273
1274 { 0x70, "pshufd", T_0F | T_66 | T_YMM | T_EVEX | T_EW0 | T_B32, true, 2 },
1275 { 0x70, "pshufhw", T_0F | T_F3 | T_YMM | T_EVEX, true, 2 },
1276 { 0x70, "pshuflw", T_0F | T_F2 | T_YMM | T_EVEX, true, 2 },
1277
1278 { 0x17, "ptest", T_0F38 | T_66 | T_YMM, false, 3 },
1279 { 0x53, "rcpps", T_0F | T_YMM, false, 2 },
1280 { 0x52, "rsqrtps", T_0F | T_YMM, false, 2 },
1281
1282 { 0x51, "sqrtpd", T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_ER_Z | T_B64, false, 2 },
1283 { 0x51, "sqrtps", T_0F | T_YMM | T_EVEX | T_EW0 | T_ER_Z | T_B32, false, 2 },
1284
1285 { 0x2E, "ucomisd", T_0F | T_66 | T_EVEX | T_EW1 | T_SAE_X | T_N8, false, 2 },
1286 { 0x2E, "ucomiss", T_0F | T_EVEX | T_EW0 | T_SAE_X | T_N4, false, 2 },
1287
1288 { 0xCC, "sha1rnds4", T_0F3A, true, 1 },
1289 { 0xC8, "sha1nexte", T_0F38, false, 1 },
1290 { 0xC9, "sha1msg1", T_0F38, false, 1 },
1291 { 0xCA, "sha1msg2", T_0F38, false, 1 },
1292 { 0xCB, "sha256rnds2", T_0F38, false, 1 },
1293 { 0xCC, "sha256msg1", T_0F38, false, 1 },
1294 { 0xCD, "sha256msg2", T_0F38, false, 1 },
1295 };
1296 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1297 const Tbl *p = &tbl[i];
1298 std::string type = type2String(p->type);
1299 if (p->mode & 1) {
1300 const char *immS1 = p->hasIMM ? ", uint8 imm" : "";
1301 const char *immS2 = p->hasIMM ? ", imm" : ", NONE";
1302 const char *pref = p->type & T_66 ? "0x66" : p->type & T_F2 ? "0xF2" : p->type & T_F3 ? "0xF3" : "NONE";
1303 const char *suf = p->type & T_0F38 ? "0x38" : p->type & T_0F3A ? "0x3A" : "NONE";
1304 printf("void %s(const Xmm& xmm, const Operand& op%s) { opGen(xmm, op, 0x%02X, %s, isXMM_XMMorMEM%s, %s); }\n", p->name, immS1, p->code, pref, immS2, suf);
1305 }
1306 if (p->mode & 2) {
1307 printf("void v%s(const Xmm& xm, const Operand& op%s) { opAVX_X_XM_IMM(xm, op, %s, 0x%02X%s); }\n"
1308 , p->name, p->hasIMM ? ", uint8 imm" : "", type.c_str(), p->code, p->hasIMM ? ", imm" : "");
1309 }
1310 }
1311 }
1312 // (m, x), (m, y)
1313 {
1314 const struct Tbl {
1315 uint8 code;
1316 const char *name;
1317 int type;
1318 } tbl[] = {
1319 { 0x29, "movapd", T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_M_K },
1320 { 0x29, "movaps", T_0F | T_YMM | T_EVEX | T_EW0 | T_M_K },
1321 { 0x7F, "movdqa", T_0F | T_66 | T_YMM },
1322 { 0x7F, "movdqu", T_0F | T_F3 | T_YMM },
1323 { 0x11, "movupd", T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_M_K },
1324 { 0x11, "movups", T_0F | T_YMM | T_EVEX | T_EW0 | T_M_K },
1325 };
1326 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1327 const Tbl *p = &tbl[i];
1328 std::string type = type2String(p->type);
1329 printf("void v%s(const Address& addr, const Xmm& xmm) { opAVX_X_XM_IMM(xmm, addr, %s, 0x%02X); }\n"
1330 , p->name, type.c_str(), p->code);
1331 }
1332 }
1333 // (x, x/m), (y, y/m), (x, x, x/m), (y, y, y/m)
1334 {
1335 const struct Tbl {
1336 uint8 code;
1337 const char *name;
1338 int type;
1339 int mode; // 1 : sse, 2 : avx, 3 : sse + avx
1340 } tbl[] = {
1341 { 0xD0, "addsubpd", T_0F | T_66 | T_YMM, 3 },
1342 { 0xD0, "addsubps", T_0F | T_F2 | T_YMM, 3 },
1343 { 0x7C, "haddpd", T_0F | T_66 | T_YMM, 3 },
1344 { 0x7C, "haddps", T_0F | T_F2 | T_YMM, 3 },
1345 { 0x7D, "hsubpd", T_0F | T_66 | T_YMM, 3 },
1346 { 0x7D, "hsubps", T_0F | T_F2 | T_YMM, 3 },
1347
1348 { 0xDC, "aesenc", T_0F38 | T_66 | T_YMM | T_EVEX, 3 },
1349 { 0xDD, "aesenclast", T_0F38 | T_66 | T_YMM | T_EVEX, 3 },
1350 { 0xDE, "aesdec", T_0F38 | T_66 | T_YMM | T_EVEX, 3 },
1351 { 0xDF, "aesdeclast", T_0F38 | T_66 | T_YMM | T_EVEX, 3 },
1352 };
1353 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1354 const Tbl *p = &tbl[i];
1355 std::string type = type2String(p->type);
1356 if (p->mode & 1) {
1357 uint8 pref = p->type & T_66 ? 0x66 : p->type & T_F2 ? 0xF2 : p->type & T_F3 ? 0xF3 : 0;
1358 printf("void %s(const Xmm& xmm, const Operand& op) { opGen(xmm, op, 0x%02X, 0x%02X, isXMM_XMMorMEM%s); }\n", p->name, p->code, pref, p->type & T_0F38 ? ", NONE, 0x38" : "");
1359 }
1360 if (p->mode & 2) {
1361 printf("void v%s(const Xmm& xmm, const Operand& op1, const Operand& op2 = Operand()) { opAVX_X_X_XM(xmm, op1, op2, %s, 0x%02X); }\n"
1362 , p->name, type.c_str(), p->code);
1363 }
1364 }
1365 }
1366 // vmaskmov
1367 {
1368 const char suf[][8] = { "ps", "pd" };
1369 for (int i = 0; i < 2; i++) {
1370 printf("void vmaskmov%s(const Xmm& x1, const Xmm& x2, const Address& addr) { opAVX_X_X_XM(x1, x2, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x%02X); }\n", suf[i], 0x2C + i);
1371 printf("void vmaskmov%s(const Address& addr, const Xmm& x1, const Xmm& x2) { opAVX_X_X_XM(x2, x1, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x%02X); }\n", suf[i], 0x2E + i);
1372 }
1373 }
1374 // vpmaskmov
1375 {
1376 const char suf[][8] = { "d", "q" };
1377 for (int i = 0; i < 2; i++) {
1378 printf("void vpmaskmov%s(const Xmm& x1, const Xmm& x2, const Address& addr) { opAVX_X_X_XM(x1, x2, addr, T_0F38 | T_66 | T_W%d | T_YMM, 0x%02X); }\n", suf[i], i, 0x8C);
1379 printf("void vpmaskmov%s(const Address& addr, const Xmm& x1, const Xmm& x2) { opAVX_X_X_XM(x2, x1, addr, T_0F38 | T_66 | T_W%d | T_YMM, 0x%02X); }\n", suf[i], i, 0x8E);
1380 }
1381 }
1382 // vpermd, vpermps
1383 {
1384 const struct Tbl {
1385 uint8 code;
1386 const char *name;
1387 int type;
1388 } tbl[] = {
1389 { 0x36, "vpermd", T_66 | T_0F38 | T_W0 | T_YMM | T_EVEX | T_EW0 | T_B32 },
1390 { 0x36, "vpermq", T_66 | T_0F38 | T_W0 | T_YMM | T_EVEX | T_EW1 | T_B64 },
1391 { 0x16, "vpermps", T_66 | T_0F38 | T_W0 | T_YMM | T_EVEX | T_EW0 | T_B32 },
1392 { 0x16, "vpermpd", T_66 | T_0F38 | T_MUST_EVEX | T_EW1 | T_YMM | T_B64 },
1393 };
1394 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1395 const Tbl& p = tbl[i];
1396 std::string type = type2String(p.type);
1397 printf("void %s(const Ymm& y1, const Ymm& y2, const Operand& op) { opAVX_X_X_XM(y1, y2, op, %s, 0x%02X); }\n", p.name, type.c_str(), p.code);
1398 }
1399 }
1400 // vpermq, vpermpd
1401 {
1402 const struct Tbl {
1403 uint8 code;
1404 const char *name;
1405 int type;
1406 } tbl[] = {
1407 { 0x00, "vpermq", T_0F3A | T_66 | T_W1 | T_YMM | T_EVEX | T_EW1 | T_B64 },
1408 { 0x01, "vpermpd", T_0F3A | T_66 | T_W1 | T_YMM | T_EVEX | T_EW1 | T_B64 },
1409 };
1410 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1411 const Tbl& p = tbl[i];
1412 std::string type = type2String(p.type);
1413 printf("void %s(const Ymm& y, const Operand& op, uint8 imm) { opAVX_X_XM_IMM(y, op, %s, 0x%02X, imm); }\n", p.name, type.c_str(), p.code);
1414 }
1415 }
1416 // vcmpeqps
1417 {
1418 const char pred[32][16] = {
1419 "eq", "lt", "le", "unord", "neq", "nlt", "nle", "ord",
1420 "eq_uq", "nge", "ngt", "false", "neq_oq", "ge", "gt",
1421 "true", "eq_os", "lt_oq", "le_oq", "unord_s", "neq_us", "nlt_uq", "nle_uq", "ord_s",
1422 "eq_us", "nge_uq", "ngt_uq", "false_os", "neq_os", "ge_oq", "gt_oq", "true_us"
1423 };
1424 const char suf[][4] = { "pd", "ps", "sd", "ss" };
1425 for (int i = 0; i < 4; i++) {
1426 const char *s = suf[i];
1427 for (int j = 0; j < 32; j++) {
1428 if (j < 8) {
1429 printf("void cmp%s%s(const Xmm& x, const Operand& op) { cmp%s(x, op, %d); }\n", pred[j], s, s, j);
1430 }
1431 printf("void vcmp%s%s(const Xmm& x1, const Xmm& x2, const Operand& op) { vcmp%s(x1, x2, op, %d); }\n", pred[j], s, s, j);
1432 }
1433 }
1434 }
1435 // vmov(h|l)(pd|ps)
1436 {
1437 const struct Tbl {
1438 bool isH;
1439 bool isPd;
1440 uint8 code;
1441 } tbl[] = {
1442 { true, true, 0x16 },
1443 { true, false, 0x16 },
1444 { false, true, 0x12 },
1445 { false, false, 0x12 },
1446 };
1447 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1448 const Tbl& p = tbl[i];
1449 char c = p.isH ? 'h' : 'l';
1450 const char *suf = p.isPd ? "pd" : "ps";
1451 const char *type = p.isPd ? "T_0F | T_66 | T_EVEX | T_EW1 | T_N8" : "T_0F | T_EVEX | T_EW0 | T_N8";
1452 printf("void vmov%c%s(const Xmm& x, const Operand& op1, const Operand& op2 = Operand()) { if (!op2.isNone() && !op2.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, op1, op2, %s, 0x%02X); }\n"
1453 , c, suf, type, p.code);
1454 printf("void vmov%c%s(const Address& addr, const Xmm& x) { opAVX_X_X_XM(x, xm0, addr, %s, 0x%02X); }\n"
1455 , c, suf, type, p.code + 1);
1456 }
1457 }
1458 // FMA
1459 {
1460 const struct Tbl {
1461 uint8 code;
1462 const char *name;
1463 bool supportYMM;
1464 } tbl[] = {
1465 { 0x08, "vfmadd", true },
1466 { 0x09, "vfmadd", false },
1467 { 0x06, "vfmaddsub", true },
1468 { 0x07, "vfmsubadd", true },
1469 { 0x0A, "vfmsub", true },
1470 { 0x0B, "vfmsub", false },
1471 { 0x0C, "vfnmadd", true },
1472 { 0x0D, "vfnmadd", false },
1473 { 0x0E, "vfnmsub", true },
1474 { 0x0F, "vfnmsub", false },
1475 };
1476 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1477 for (int j = 0; j < 2; j++) {
1478 const char sufTbl[][2][8] = {
1479 { "pd", "ps" },
1480 { "sd", "ss" },
1481 };
1482 for (int k = 0; k < 3; k++) {
1483 const struct Ord {
1484 const char *str;
1485 uint8 code;
1486 } ord[] = {
1487 { "132", 0x90 },
1488 { "213", 0xA0 },
1489 { "231", 0xB0 },
1490 };
1491 int t = T_0F38 | T_66 | T_EVEX;
1492 t |= (j == 0) ? (T_W1 | T_EW1) : (T_W0 | T_EW0);
1493 if (tbl[i].supportYMM) t |= T_YMM;
1494 const std::string suf = sufTbl[tbl[i].supportYMM ? 0 : 1][j];
1495 if (suf == "pd") {
1496 t |= T_B64;
1497 } else if (suf == "ps") {
1498 t |= T_B32;
1499 } else if (suf == "sd") {
1500 t |= T_ER_X | T_N8;
1501 } else { // ss
1502 t |= T_ER_X | T_N4;
1503 }
1504 std::string type = type2String(t);
1505 printf("void %s%s%s(const Xmm& x1, const Xmm& x2, const Operand& op) { opAVX_X_X_XM(x1, x2, op, %s, 0x%02X); }\n"
1506 , tbl[i].name, ord[k].str, suf.c_str(), type.c_str(), tbl[i].code + ord[k].code);
1507 }
1508 }
1509 }
1510 }
1511 // FMA others
1512 {
1513 printf("void vbroadcastf128(const Ymm& y, const Address& addr) { opAVX_X_XM_IMM(y, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x1A); }\n");
1514 printf("void vbroadcasti128(const Ymm& y, const Address& addr) { opAVX_X_XM_IMM(y, addr, T_0F38 | T_66 | T_W0 | T_YMM, 0x5A); }\n");
1515 printf("void vbroadcastsd(const Ymm& y, const Operand& op) { if (!op.isMEM() && !(y.isYMM() && op.isXMM()) && !(y.isZMM() && op.isXMM())) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_XM_IMM(y, op, T_0F38 | T_66 | T_W0 | T_YMM | T_EVEX | T_EW1 | T_N8, 0x19); }\n");
1516 const struct Tbl {
1517 const char *name;
1518 uint8 code;
1519 int type;
1520 bool ew1;
1521 } tbl[] = {
1522 { "vbroadcastss", 0x18, T_0F38 | T_66 | T_W0 | T_YMM | T_EVEX | T_N4 },
1523 { "vpbroadcastb", 0x78, T_0F38 | T_66 | T_W0 | T_YMM | T_EVEX | T_N1 },
1524 { "vpbroadcastw", 0x79, T_0F38 | T_66 | T_W0 | T_YMM | T_EVEX | T_N2 },
1525 { "vpbroadcastd", 0x58, T_0F38 | T_66 | T_W0 | T_YMM | T_EVEX | T_N4 },
1526 { "vpbroadcastq", 0x59, T_0F38 | T_66 | T_W0 | T_YMM | T_EVEX | T_EW1 | T_N8 },
1527 };
1528 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1529 const Tbl& p = tbl[i];
1530 std::string type = type2String(p.type);
1531 printf("void %s(const Xmm& x, const Operand& op) { if (!(op.isXMM() || op.isMEM())) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_XM_IMM(x, op, %s, 0x%02X); }\n", p.name, type.c_str(), p.code);
1532 }
1533
1534 puts("void vextractf128(const Operand& op, const Ymm& y, uint8 imm) { if (!(op.isXMEM() && y.isYMM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y, 0, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x19, imm); }");
1535 puts("void vextracti128(const Operand& op, const Ymm& y, uint8 imm) { if (!(op.isXMEM() && y.isYMM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y, 0, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x39, imm); }");
1536 puts("void vextractps(const Operand& op, const Xmm& x, uint8 imm) { if (!((op.isREG(32) || op.isMEM()) && x.isXMM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x, 0, op, T_0F3A | T_66 | T_W0 | T_EVEX | T_N4, 0x17, imm); }");
1537 puts("void vinsertf128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8 imm) { if (!(y1.isYMM() && y2.isYMM() && op.isXMEM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y1, &y2, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x18, imm); }");
1538 puts("void vinserti128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8 imm) { if (!(y1.isYMM() && y2.isYMM() && op.isXMEM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y1, &y2, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x38, imm); }");
1539 puts("void vperm2f128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8 imm) { if (!(y1.isYMM() && y2.isYMM() && op.isYMEM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y1, &y2, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x06, imm); }");
1540 puts("void vperm2i128(const Ymm& y1, const Ymm& y2, const Operand& op, uint8 imm) { if (!(y1.isYMM() && y2.isYMM() && op.isYMEM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(y1, &y2, op, T_0F3A | T_66 | T_W0 | T_YMM, 0x46, imm); }");
1541
1542 puts("void vlddqu(const Xmm& x, const Address& addr) { opAVX_X_X_XM(x, cvtIdx0(x), addr, T_0F | T_F2 | T_W0 | T_YMM, 0xF0); }");
1543 puts("void vldmxcsr(const Address& addr) { opAVX_X_X_XM(xm2, xm0, addr, T_0F, 0xAE); }");
1544 puts("void vstmxcsr(const Address& addr) { opAVX_X_X_XM(xm3, xm0, addr, T_0F, 0xAE); }");
1545 puts("void vmaskmovdqu(const Xmm& x1, const Xmm& x2) { opAVX_X_X_XM(x1, xm0, x2, T_0F | T_66, 0xF7); }");
1546
1547 puts("void vpextrb(const Operand& op, const Xmm& x, uint8 imm) { if (!((op.isREG(8|16|i32e) || op.isMEM()) && x.isXMM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x, 0, op, T_0F3A | T_66 | T_EVEX | T_N1, 0x14, imm); }");
1548 puts("void vpextrw(const Operand& op, const Xmm& x, uint8 imm) { if (!((op.isREG(16|i32e) || op.isMEM()) && x.isXMM())) XBYAK_THROW(ERR_BAD_COMBINATION) if (op.isREG() && x.getIdx() < 16) { opAVX_X_X_XM(Xmm(op.getIdx()), xm0, x, T_0F | T_66, 0xC5, imm); } else { opVex(x, 0, op, T_0F3A | T_66 | T_EVEX | T_N2, 0x15, imm); } }");
1549 puts("void vpextrd(const Operand& op, const Xmm& x, uint8 imm) { if (!((op.isREG(32) || op.isMEM()) && x.isXMM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x, 0, op, T_0F3A | T_66 | T_W0 | T_EVEX | T_EW0 | T_N4, 0x16, imm); }");
1550 puts("void vpextrq(const Operand& op, const Xmm& x, uint8 imm) { if (!((op.isREG(64) || op.isMEM()) && x.isXMM())) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x, 0, op, T_0F3A | T_66 | T_W1 | T_EVEX | T_EW1 | T_N8, 0x16, imm); }");
1551
1552 puts("void vpinsrb(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm) { if (!(x1.isXMM() && x2.isXMM() && (op.isREG(32) || op.isMEM()))) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x1, &x2, op, T_0F3A | T_66 | T_EVEX | T_N1, 0x20, imm); }");
1553 puts("void vpinsrw(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm) { if (!(x1.isXMM() && x2.isXMM() && (op.isREG(32) || op.isMEM()))) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x1, &x2, op, T_0F | T_66 | T_EVEX | T_N2, 0xC4, imm); }");
1554 puts("void vpinsrd(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm) { if (!(x1.isXMM() && x2.isXMM() && (op.isREG(32) || op.isMEM()))) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x1, &x2, op, T_0F3A | T_66 | T_W0 | T_EVEX | T_EW0 | T_N4, 0x22, imm); }");
1555 puts("void vpinsrq(const Xmm& x1, const Xmm& x2, const Operand& op, uint8 imm) { if (!(x1.isXMM() && x2.isXMM() && (op.isREG(64) || op.isMEM()))) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x1, &x2, op, T_0F3A | T_66 | T_W1 | T_EVEX | T_EW1 | T_N8, 0x22, imm); }");
1556
1557 puts("void vpmovmskb(const Reg32e& r, const Xmm& x) { if (!x.is(Operand::XMM | Operand::YMM)) XBYAK_THROW(ERR_BAD_COMBINATION) opVex(x.isYMM() ? Ymm(r.getIdx()) : Xmm(r.getIdx()), 0, x, T_0F | T_66 | T_YMM, 0xD7); }");
1558
1559 }
1560 // (x, x, imm), (x, imm)
1561 {
1562 const struct Tbl {
1563 const char *name;
1564 uint8 code;
1565 int idx;
1566 int type;
1567 } tbl[] = {
1568 { "pslldq", 0x73, 7, T_0F | T_66 | T_YMM | T_EVEX | T_MEM_EVEX },
1569 { "psrldq", 0x73, 3, T_0F | T_66 | T_YMM | T_EVEX | T_MEM_EVEX },
1570 { "psllw", 0x71, 6, T_0F | T_66 | T_YMM | T_EVEX | T_MEM_EVEX },
1571 { "pslld", 0x72, 6, T_0F | T_66 | T_YMM | T_EVEX | T_MEM_EVEX | T_EW0 | T_B32 },
1572 { "psllq", 0x73, 6, T_0F | T_66 | T_YMM | T_EVEX | T_MEM_EVEX | T_EW1 | T_B64 },
1573 { "psraw", 0x71, 4, T_0F | T_66 | T_YMM | T_EVEX | T_MEM_EVEX },
1574 { "psrad", 0x72, 4, T_0F | T_66 | T_YMM | T_EVEX | T_MEM_EVEX | T_EW0 | T_B32 },
1575 { "psrlw", 0x71, 2, T_0F | T_66 | T_YMM | T_EVEX | T_MEM_EVEX },
1576 { "psrld", 0x72, 2, T_0F | T_66 | T_YMM | T_EVEX | T_MEM_EVEX | T_EW0 | T_B32 },
1577 { "psrlq", 0x73, 2, T_0F | T_66 | T_YMM | T_EVEX | T_MEM_EVEX | T_EW1 | T_B64 },
1578 };
1579 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1580 const Tbl& p = tbl[i];
1581 std::string type = type2String(p.type);
1582 printf("void v%s(const Xmm& x, const Operand& op, uint8 imm) { opAVX_X_X_XM(Xmm(x.getKind(), %d), x, op, %s, 0x%02X, imm); }\n", p.name, p.idx, type.c_str(), p.code);
1583 }
1584 }
1585 // 4-op
1586 {
1587 const struct Tbl {
1588 const char *name;
1589 uint8 code;
1590 } tbl[] = {
1591 { "vblendvpd", 0x4B },
1592 { "vblendvps", 0x4A },
1593 { "vpblendvb", 0x4C },
1594 };
1595 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1596 const Tbl& p = tbl[i];
1597 printf("void %s(const Xmm& x1, const Xmm& x2, const Operand& op, const Xmm& x4) { opAVX_X_X_XM(x1, x2, op, T_0F3A | T_66 | T_YMM, 0x%02X, x4.getIdx() << 4); }\n", p.name, p.code);
1598 }
1599 }
1600 // mov
1601 {
1602 printf("void vmovd(const Xmm& x, const Operand& op) { if (!op.isREG(32) && !op.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, xm0, op, T_0F | T_66 | T_W0 | T_EVEX | T_N4, 0x6E); }\n");
1603 printf("void vmovd(const Operand& op, const Xmm& x) { if (!op.isREG(32) && !op.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x, xm0, op, T_0F | T_66 | T_W0 | T_EVEX | T_N4, 0x7E); }\n");
1604
1605 printf("void vmovq(const Xmm& x, const Address& addr) { int type, code; if (x.getIdx() < 16) { type = T_0F | T_F3; code = 0x7E; } else { type = T_0F | T_66 | T_EVEX | T_EW1 | T_N8; code = 0x6E; } opAVX_X_X_XM(x, xm0, addr, type, code); }\n");
1606 printf("void vmovq(const Address& addr, const Xmm& x) { opAVX_X_X_XM(x, xm0, addr, T_0F | T_66 | T_EVEX | T_EW1 | T_N8, x.getIdx() < 16 ? 0xD6 : 0x7E); }\n");
1607 printf("void vmovq(const Xmm& x1, const Xmm& x2) { opAVX_X_X_XM(x1, xm0, x2, T_0F | T_F3 | T_EVEX | T_EW1 | T_N8, 0x7E); }\n");
1608
1609 printf("void vmovhlps(const Xmm& x1, const Xmm& x2, const Operand& op = Operand()) { if (!op.isNone() && !op.isXMM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x1, x2, op, T_0F | T_EVEX | T_EW0, 0x12); }\n");
1610 printf("void vmovlhps(const Xmm& x1, const Xmm& x2, const Operand& op = Operand()) { if (!op.isNone() && !op.isXMM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x1, x2, op, T_0F | T_EVEX | T_EW0, 0x16); }\n");
1611
1612 printf("void vmovmskpd(const Reg& r, const Xmm& x) { if (!r.isBit(i32e)) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x.isXMM() ? Xmm(r.getIdx()) : Ymm(r.getIdx()), cvtIdx0(x), x, T_0F | T_66 | T_W0 | T_YMM, 0x50); }\n");
1613 printf("void vmovmskps(const Reg& r, const Xmm& x) { if (!r.isBit(i32e)) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x.isXMM() ? Xmm(r.getIdx()) : Ymm(r.getIdx()), cvtIdx0(x), x, T_0F | T_W0 | T_YMM, 0x50); }\n");
1614
1615 puts("void vmovntdq(const Address& addr, const Xmm& x) { opVex(x, 0, addr, T_0F | T_66 | T_YMM | T_EVEX | T_EW0, 0xE7); }");
1616 puts("void vmovntpd(const Address& addr, const Xmm& x) { opVex(x, 0, addr, T_0F | T_66 | T_YMM | T_EVEX | T_EW1, 0x2B); }");
1617 puts("void vmovntps(const Address& addr, const Xmm& x) { opVex(x, 0, addr, T_0F | T_YMM | T_EVEX | T_EW0, 0x2B); }");
1618 puts("void vmovntdqa(const Xmm& x, const Address& addr) { opVex(x, 0, addr, T_0F38 | T_66 | T_YMM | T_EVEX | T_EW0, 0x2A); }");
1619
1620 // vmovsd, vmovss
1621 for (int i = 0; i < 2; i++) {
1622 char c1 = i == 0 ? 'd' : 's';
1623 int type = T_0F | T_EVEX;
1624 type |= i == 0 ? (T_F2 | T_EW1 | T_N8) : (T_F3 | T_EW0 | T_N4);
1625 std::string s = type2String(type);
1626 printf("void vmovs%c(const Xmm& x1, const Xmm& x2, const Operand& op = Operand()) { if (!op.isNone() && !op.isXMM()) XBYAK_THROW(ERR_BAD_COMBINATION) opAVX_X_X_XM(x1, x2, op, %s, 0x10); }\n", c1, s.c_str());
1627 printf("void vmovs%c(const Xmm& x, const Address& addr) { opAVX_X_X_XM(x, xm0, addr, %s, 0x10); }\n", c1, s.c_str());
1628 printf("void vmovs%c(const Address& addr, const Xmm& x) { opAVX_X_X_XM(x, xm0, addr, %s | T_M_K, 0x11); }\n", c1, s.c_str());
1629 }
1630 }
1631 // cvt
1632 {
1633 puts("void vcvtss2si(const Reg32& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F3 | T_W0 | T_EVEX | T_EW0 | T_ER_X | T_N8, 0x2D); }");
1634 puts("void vcvttss2si(const Reg32& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F3 | T_W0 | T_EVEX | T_EW0 | T_SAE_X | T_N8, 0x2C); }");
1635 puts("void vcvtsd2si(const Reg32& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F2 | T_W0 | T_EVEX | T_EW0 | T_N4 | T_ER_X, 0x2D); }");
1636 puts("void vcvttsd2si(const Reg32& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F2 | T_W0 | T_EVEX | T_EW0 | T_N4 | T_SAE_X, 0x2C); }");
1637
1638 puts("void vcvtsi2ss(const Xmm& x1, const Xmm& x2, const Operand& op) { opCvt3(x1, x2, op, T_0F | T_F3 | T_EVEX | T_ER_X, T_W1 | T_EW1 | T_N8, T_W0 | T_EW0 | T_N4, 0x2A); }");
1639 puts("void vcvtsi2sd(const Xmm& x1, const Xmm& x2, const Operand& op) { opCvt3(x1, x2, op, T_0F | T_F2 | T_EVEX, T_W1 | T_EW1 | T_ER_X | T_N8, T_W0 | T_EW0 | T_N4, 0x2A); }");
1640
1641
1642 puts("void vcvtps2pd(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_0F | T_YMM | T_EVEX | T_EW0 | T_B32 | T_N8 | T_N_VL | T_SAE_Y, 0x5A); }");
1643 puts("void vcvtdq2pd(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_0F | T_F3 | T_YMM | T_EVEX | T_EW0 | T_B32 | T_N8 | T_N_VL, 0xE6); }");
1644
1645 puts("void vcvtpd2ps(const Xmm& x, const Operand& op) { opCvt2(x, op, T_0F | T_66 | T_YMM | T_EVEX | T_EW1 | T_B64 | T_ER_Z, 0x5A); }");
1646 puts("void vcvtpd2dq(const Xmm& x, const Operand& op) { opCvt2(x, op, T_0F | T_F2 | T_YMM | T_EVEX | T_EW1 | T_B64 | T_ER_Z, 0xE6); }");
1647
1648 puts("void vcvttpd2dq(const Xmm& x, const Operand& op) { opCvt2(x, op, T_66 | T_0F | T_YMM | T_EVEX |T_EW1 | T_B64 | T_ER_Z, 0xE6); }");
1649
1650 puts("void vcvtph2ps(const Xmm& x, const Operand& op) { checkCvt1(x, op); opVex(x, 0, op, T_0F38 | T_66 | T_W0 | T_EVEX | T_EW0 | T_N8 | T_N_VL | T_SAE_Y, 0x13); }");
1651 puts("void vcvtps2ph(const Operand& op, const Xmm& x, uint8 imm) { checkCvt1(x, op); opVex(x, 0, op, T_0F3A | T_66 | T_W0 | T_EVEX | T_EW0 | T_N8 | T_N_VL | T_SAE_Y, 0x1D, imm); }");
1652
1653 }
1654 // haswell gpr(reg, reg, r/m)
1655 {
1656 const struct Tbl {
1657 const char *name;
1658 int type;
1659 uint8 code;
1660 } tbl[] = {
1661 { "andn", T_0F38, 0xF2 },
1662 { "mulx", T_F2 | T_0F38, 0xF6 },
1663 { "pdep", T_F2 | T_0F38, 0xF5 },
1664 { "pext", T_F3 | T_0F38, 0xF5 },
1665 };
1666 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1667 const Tbl& p = tbl[i];
1668 printf("void %s(const Reg32e& r1, const Reg32e& r2, const Operand& op) { opGpr(r1, r2, op, %s, 0x%x, true); }\n", p.name, type2String(p.type).c_str(), p.code);
1669 }
1670 }
1671 // gpr(reg, r/m, reg)
1672 {
1673 const struct Tbl {
1674 const char *name;
1675 int type;
1676 uint8 code;
1677 } tbl[] = {
1678 { "bextr", T_0F38, 0xF7 },
1679 { "bzhi", T_0F38, 0xF5 },
1680 { "sarx", T_0F38 | T_F3, 0xF7 },
1681 { "shlx", T_0F38 | T_66, 0xF7 },
1682 { "shrx", T_0F38 | T_F2, 0xF7 },
1683 };
1684 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1685 const Tbl& p = tbl[i];
1686 printf("void %s(const Reg32e& r1, const Operand& op, const Reg32e& r2) { opGpr(r1, op, r2, %s, 0x%x, false); }\n", p.name, type2String(p.type).c_str(), p.code);
1687 }
1688 puts("void rorx(const Reg32e& r, const Operand& op, uint8 imm) { opGpr(r, op, Reg32e(0, r.getBit()), T_0F3A | T_F2, 0xF0, false, imm); }");
1689 }
1690 // gpr(reg, r/m)
1691 {
1692 const struct Tbl {
1693 const char *name;
1694 int type;
1695 uint8 code;
1696 uint8 idx;
1697 } tbl[] = {
1698 { "blsi", T_0F38, 0xF3, 3 },
1699 { "blsmsk", T_0F38, 0xF3, 2 },
1700 { "blsr", T_0F38, 0xF3, 1 },
1701 };
1702 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1703 const Tbl& p = tbl[i];
1704 printf("void %s(const Reg32e& r, const Operand& op) { opGpr(Reg32e(%d, r.getBit()), op, r, %s, 0x%x, false); }\n", p.name, p.idx, type2String(p.type).c_str(), p.code);
1705 }
1706 }
1707 // gather
1708 {
1709 const int y_vx_y = 0;
1710 const int y_vy_y = 1;
1711 const int x_vy_x = 2;
1712 const struct Tbl {
1713 const char *name;
1714 uint8 code;
1715 int w;
1716 int mode;
1717 } tbl[] = {
1718 { "vgatherdpd", 0x92, 1, y_vx_y },
1719 { "vgatherqpd", 0x93, 1, y_vy_y },
1720 { "vgatherdps", 0x92, 0, y_vy_y },
1721 { "vgatherqps", 0x93, 0, x_vy_x },
1722 { "vpgatherdd", 0x90, 0, y_vy_y },
1723 { "vpgatherqd", 0x91, 0, x_vy_x },
1724 { "vpgatherdq", 0x90, 1, y_vx_y },
1725 { "vpgatherqq", 0x91, 1, y_vy_y },
1726 };
1727 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1728 const Tbl& p = tbl[i];
1729 printf("void %s(const Xmm& x1, const Address& addr, const Xmm& x2) { opGather(x1, addr, x2, T_0F38 | T_66 | T_YMM | T_VSIB | T_W%d, 0x%x, %d); }\n", p.name, p.w, p.code, p.mode);
1730 }
1731 }
1732 }
1733
put32()1734 void put32()
1735 {
1736 put_jREGz("cx", true);
1737 put_jREGz("ecx", false);
1738
1739 const GenericTbl tbl[] = {
1740 { "aaa", 0x37 },
1741 { "aad", 0xD5, 0x0A },
1742 { "aam", 0xD4, 0x0A },
1743 { "aas", 0x3F },
1744 { "daa", 0x27 },
1745 { "das", 0x2F },
1746 { "into", 0xCE },
1747 { "popad", 0x61 },
1748 { "popfd", 0x9D },
1749 { "pusha", 0x60 },
1750 { "pushad", 0x60 },
1751 { "pushfd", 0x9C },
1752 { "popa", 0x61 },
1753 };
1754 putGeneric(tbl, NUM_OF_ARRAY(tbl));
1755 putLoadSeg("lds", 0xC5, NONE);
1756 putLoadSeg("les", 0xC4, NONE);
1757 }
1758
put64()1759 void put64()
1760 {
1761 put_jREGz("ecx", true);
1762 put_jREGz("rcx", false);
1763
1764 const GenericTbl tbl[] = {
1765 { "cdqe", 0x48, 0x98 },
1766 { "cqo", 0x48, 0x99 },
1767 { "cmpsq", 0x48, 0xA7 },
1768 { "popfq", 0x9D },
1769 { "pushfq", 0x9C },
1770 { "lodsq", 0x48, 0xAD },
1771 { "movsq", 0x48, 0xA5 },
1772 { "scasq", 0x48, 0xAF },
1773 { "stosq", 0x48, 0xAB },
1774 { "syscall", 0x0F, 0x05 },
1775 { "sysret", 0x0F, 0x07 },
1776 };
1777 putGeneric(tbl, NUM_OF_ARRAY(tbl));
1778
1779 putMemOp("cmpxchg16b", 0, 1, 0x0F, 0xC7, 64);
1780 putMemOp("fxrstor64", 0, 1, 0x0F, 0xAE, 64);
1781 puts("void movq(const Reg64& reg, const Mmx& mmx) { if (mmx.isXMM()) db(0x66); opModR(mmx, reg, 0x0F, 0x7E); }");
1782 puts("void movq(const Mmx& mmx, const Reg64& reg) { if (mmx.isXMM()) db(0x66); opModR(mmx, reg, 0x0F, 0x6E); }");
1783 puts("void movsxd(const Reg64& reg, const Operand& op) { if (!op.isBit(32)) XBYAK_THROW(ERR_BAD_COMBINATION) opModRM(reg, op, op.isREG(), op.isMEM(), 0x63); }");
1784 puts("void pextrq(const Operand& op, const Xmm& xmm, uint8 imm) { if (!op.isREG(64) && !op.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opGen(Reg64(xmm.getIdx()), op, 0x16, 0x66, 0, imm, 0x3A); }");
1785 puts("void pinsrq(const Xmm& xmm, const Operand& op, uint8 imm) { if (!op.isREG(64) && !op.isMEM()) XBYAK_THROW(ERR_BAD_COMBINATION) opGen(Reg64(xmm.getIdx()), op, 0x22, 0x66, 0, imm, 0x3A); }");
1786
1787 puts("void vcvtss2si(const Reg64& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F3 | T_W1 | T_EVEX | T_EW1 | T_ER_X | T_N8, 0x2D); }");
1788 puts("void vcvttss2si(const Reg64& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F3 | T_W1 | T_EVEX | T_EW1 | T_SAE_X | T_N8, 0x2C); }");
1789 puts("void vcvtsd2si(const Reg64& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F2 | T_W1 | T_EVEX | T_EW1 | T_N4 | T_ER_X, 0x2D); }");
1790 puts("void vcvttsd2si(const Reg64& r, const Operand& op) { opAVX_X_X_XM(Xmm(r.getIdx()), xm0, op, T_0F | T_F2 | T_W1 | T_EVEX | T_EW1 | T_N4 | T_SAE_X, 0x2C); }");
1791
1792 puts("void vmovq(const Xmm& x, const Reg64& r) { opAVX_X_X_XM(x, xm0, Xmm(r.getIdx()), T_66 | T_0F | T_W1 | T_EVEX | T_EW1, 0x6E); }");
1793 puts("void vmovq(const Reg64& r, const Xmm& x) { opAVX_X_X_XM(x, xm0, Xmm(r.getIdx()), T_66 | T_0F | T_W1 | T_EVEX | T_EW1, 0x7E); }");
1794 }
1795
putAMX_TILE()1796 void putAMX_TILE()
1797 {
1798 puts("void ldtilecfg(const Address& addr) { opVex(tmm0, &tmm0, addr, T_0F38 | T_W0, 0x49); }");
1799 puts("void sttilecfg(const Address& addr) { opVex(tmm0, &tmm0, addr, T_66 | T_0F38 | T_W0, 0x49); }");
1800 puts("void tileloadd(const Tmm& tm, const Address& addr) { opAMX(tm, addr, T_F2 | T_0F38 | T_W0, 0x4b); }");
1801 puts("void tileloaddt1(const Tmm& tm, const Address& addr) { opAMX(tm, addr, T_66 | T_0F38 | T_W0, 0x4b); }");
1802 puts("void tilerelease() { db(0xc4); db(0xe2); db(0x78); db(0x49); db(0xc0); }");
1803 puts("void tilestored(const Address& addr, const Tmm& tm) { opVex(tm, &tmm0, addr, T_F3 | T_0F38 | T_W0, 0x4b); }");
1804 puts("void tilezero(const Tmm& Tmm) { opVex(Tmm, &tmm0, tmm0, T_F2 | T_0F38 | T_W0, 0x49); }");
1805 }
putAMX_INT8()1806 void putAMX_INT8()
1807 {
1808 puts("void tdpbssd(const Tmm& x1, const Tmm& x2, const Tmm& x3) { opVex(x1, &x3, x2, T_F2 | T_0F38 | T_W0, 0x5e); }");
1809 puts("void tdpbsud(const Tmm& x1, const Tmm& x2, const Tmm& x3) { opVex(x1, &x3, x2, T_F3 | T_0F38 | T_W0, 0x5e); }");
1810 puts("void tdpbusd(const Tmm& x1, const Tmm& x2, const Tmm& x3) { opVex(x1, &x3, x2, T_66 | T_0F38 | T_W0, 0x5e); }");
1811 puts("void tdpbuud(const Tmm& x1, const Tmm& x2, const Tmm& x3) { opVex(x1, &x3, x2, T_0F38 | T_W0, 0x5e); }");
1812 }
putAMX_BF16()1813 void putAMX_BF16()
1814 {
1815 puts("void tdpbf16ps(const Tmm& x1, const Tmm& x2, const Tmm& x3) { opVex(x1, &x3, x2, T_F3 | T_0F38 | T_W0, 0x5c); }");
1816 }
1817
putFixed()1818 void putFixed()
1819 {
1820 puts("#ifdef XBYAK64");
1821 put64();
1822 putAMX_TILE();
1823 putAMX_INT8();
1824 putAMX_BF16();
1825 puts("#else");
1826 put32();
1827 puts("#endif");
1828 puts("#ifndef XBYAK_NO_OP_NAMES");
1829 const char *tbl[] = {
1830 "and", "or", "xor",
1831 };
1832 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1833 const char *name = tbl[i];
1834 printf("void %s(const Operand& op1, const Operand& op2) { %s_(op1, op2); }\n", name, name);
1835 printf("void %s(const Operand& op, uint32 imm) { %s_(op, imm); }\n", name, name);
1836 }
1837 puts("void not(const Operand& op) { not_(op); }");
1838 puts("#endif");
1839 }
1840
putOmit()1841 void putOmit()
1842 {
1843 puts("void vpinsrb(const Xmm& x, const Operand& op, uint8 imm) { vpinsrb(x, x, op, imm); }");
1844 puts("void vpinsrd(const Xmm& x, const Operand& op, uint8 imm) { vpinsrd(x, x, op, imm); }");
1845 puts("void vpinsrq(const Xmm& x, const Operand& op, uint8 imm) { vpinsrq(x, x, op, imm); }");
1846 puts("void vpinsrw(const Xmm& x, const Operand& op, uint8 imm) { vpinsrw(x, x, op, imm); }");
1847
1848 puts("void vcvtsi2sd(const Xmm& x, const Operand& op) { vcvtsi2sd(x, x, op); }");
1849 puts("void vcvtsi2ss(const Xmm& x, const Operand& op) { vcvtsi2ss(x, x, op); }");
1850 {
1851 const char pred[32][16] = {
1852 "eq", "lt", "le", "unord", "neq", "nlt", "nle", "ord",
1853 "eq_uq", "nge", "ngt", "false", "neq_oq", "ge", "gt",
1854 "true", "eq_os", "lt_oq", "le_oq", "unord_s", "neq_us", "nlt_uq", "nle_uq", "ord_s",
1855 "eq_us", "nge_uq", "ngt_uq", "false_os", "neq_os", "ge_oq", "gt_oq", "true_us"
1856 };
1857 const char suf[][4] = { "pd", "ps", "sd", "ss" };
1858 for (int i = 0; i < 4; i++) {
1859 const char *s = suf[i];
1860 for (int j = 0; j < 32; j++) {
1861 printf("void vcmp%s%s(const Xmm& x, const Operand& op) { vcmp%s%s(x, x, op); }\n", pred[j], s, pred[j], s);
1862 }
1863 }
1864 }
1865 {
1866 const char *tbl[] = {
1867 "pslldq",
1868 "psrldq",
1869 "psllw",
1870 "pslld",
1871 "psllq",
1872 "psraw",
1873 "psrad",
1874 "psrlw",
1875 "psrld",
1876 "psrlq",
1877 };
1878 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1879 const char *name = tbl[i];
1880 printf("void v%s(const Xmm& x, uint8 imm) { v%s(x, x, imm); }\n", name, name);
1881 }
1882 }
1883 {
1884 const char *tbl[] = {
1885 "vblendvpd",
1886 "vblendvps",
1887 "vpblendvb",
1888 };
1889 for (size_t i = 0; i < NUM_OF_ARRAY(tbl); i++) {
1890 const char *name = tbl[i];
1891 printf("void %s(const Xmm& x1, const Operand& op, const Xmm& x4) { %s(x1, x1, op, x4); }\n", name, name);
1892 }
1893 }
1894 putX_X_XM(true);
1895 }
1896
main(int argc,char * argv[])1897 int main(int argc, char *argv[])
1898 {
1899 std::string mode = argc == 2 ? argv[1] : "";
1900 if (mode == "") {
1901 put();
1902 } else if (mode == "fixed") {
1903 putFixed();
1904 } else {
1905 putOmit();
1906 }
1907 }
1908