1 // Inferno utils/6l/optab.c
2 // http://code.google.com/p/inferno-os/source/browse/utils/6l/optab.c
3 //
4 // Copyright © 1994-1999 Lucent Technologies Inc. All rights reserved.
5 // Portions Copyright © 1995-1997 C H Forsyth (forsyth@terzarima.net)
6 // Portions Copyright © 1997-1999 Vita Nuova Limited
7 // Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com)
8 // Portions Copyright © 2004,2006 Bruce Ellis
9 // Portions Copyright © 2005-2007 C H Forsyth (forsyth@terzarima.net)
10 // Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
11 // Portions Copyright © 2009 The Go Authors. All rights reserved.
12 //
13 // Permission is hereby granted, free of charge, to any person obtaining a copy
14 // of this software and associated documentation files (the "Software"), to deal
15 // in the Software without restriction, including without limitation the rights
16 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
17 // copies of the Software, and to permit persons to whom the Software is
18 // furnished to do so, subject to the following conditions:
19 //
20 // The above copyright notice and this permission notice shall be included in
21 // all copies or substantial portions of the Software.
22 //
23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
24 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
26 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
28 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
29 // THE SOFTWARE.
30
31 #include "l.h"
32
33 uchar ynone[] =
34 {
35 Ynone, Ynone, Zlit, 1,
36 0
37 };
38 uchar ytext[] =
39 {
40 Ymb, Yi64, Zpseudo,1,
41 0
42 };
43 uchar ynop[] =
44 {
45 Ynone, Ynone, Zpseudo,1,
46 Ynone, Yml, Zpseudo,1,
47 Ynone, Yrf, Zpseudo,1,
48 Yml, Ynone, Zpseudo,1,
49 Yrf, Ynone, Zpseudo,1,
50 0
51 };
52 uchar yxorb[] =
53 {
54 Yi32, Yal, Zib_, 1,
55 Yi32, Ymb, Zibo_m, 2,
56 Yrb, Ymb, Zr_m, 1,
57 Ymb, Yrb, Zm_r, 1,
58 0
59 };
60 uchar yxorl[] =
61 {
62 Yi8, Yml, Zibo_m, 2,
63 Yi32, Yax, Zil_, 1,
64 Yi32, Yml, Zilo_m, 2,
65 Yrl, Yml, Zr_m, 1,
66 Yml, Yrl, Zm_r, 1,
67 0
68 };
69 uchar yaddl[] =
70 {
71 Yi8, Yml, Zibo_m, 2,
72 Yi32, Yax, Zil_, 1,
73 Yi32, Yml, Zilo_m, 2,
74 Yrl, Yml, Zr_m, 1,
75 Yml, Yrl, Zm_r, 1,
76 0
77 };
78 uchar yincb[] =
79 {
80 Ynone, Ymb, Zo_m, 2,
81 0
82 };
83 uchar yincw[] =
84 {
85 Ynone, Yml, Zo_m, 2,
86 0
87 };
88 uchar yincl[] =
89 {
90 Ynone, Yml, Zo_m, 2,
91 0
92 };
93 uchar ycmpb[] =
94 {
95 Yal, Yi32, Z_ib, 1,
96 Ymb, Yi32, Zm_ibo, 2,
97 Ymb, Yrb, Zm_r, 1,
98 Yrb, Ymb, Zr_m, 1,
99 0
100 };
101 uchar ycmpl[] =
102 {
103 Yml, Yi8, Zm_ibo, 2,
104 Yax, Yi32, Z_il, 1,
105 Yml, Yi32, Zm_ilo, 2,
106 Yml, Yrl, Zm_r, 1,
107 Yrl, Yml, Zr_m, 1,
108 0
109 };
110 uchar yshb[] =
111 {
112 Yi1, Ymb, Zo_m, 2,
113 Yi32, Ymb, Zibo_m, 2,
114 Ycx, Ymb, Zo_m, 2,
115 0
116 };
117 uchar yshl[] =
118 {
119 Yi1, Yml, Zo_m, 2,
120 Yi32, Yml, Zibo_m, 2,
121 Ycl, Yml, Zo_m, 2,
122 Ycx, Yml, Zo_m, 2,
123 0
124 };
125 uchar ytestb[] =
126 {
127 Yi32, Yal, Zib_, 1,
128 Yi32, Ymb, Zibo_m, 2,
129 Yrb, Ymb, Zr_m, 1,
130 Ymb, Yrb, Zm_r, 1,
131 0
132 };
133 uchar ytestl[] =
134 {
135 Yi32, Yax, Zil_, 1,
136 Yi32, Yml, Zilo_m, 2,
137 Yrl, Yml, Zr_m, 1,
138 Yml, Yrl, Zm_r, 1,
139 0
140 };
141 uchar ymovb[] =
142 {
143 Yrb, Ymb, Zr_m, 1,
144 Ymb, Yrb, Zm_r, 1,
145 Yi32, Yrb, Zib_rp, 1,
146 Yi32, Ymb, Zibo_m, 2,
147 0
148 };
149 uchar ymbs[] =
150 {
151 Ymb, Ynone, Zm_o, 2,
152 0
153 };
154 uchar ybtl[] =
155 {
156 Yi8, Yml, Zibo_m, 2,
157 Yrl, Yml, Zr_m, 1,
158 0
159 };
160 uchar ymovw[] =
161 {
162 Yrl, Yml, Zr_m, 1,
163 Yml, Yrl, Zm_r, 1,
164 Yi0, Yrl, Zclr, 1,
165 Yi32, Yrl, Zil_rp, 1,
166 Yi32, Yml, Zilo_m, 2,
167 Yiauto, Yrl, Zaut_r, 2,
168 0
169 };
170 uchar ymovl[] =
171 {
172 Yrl, Yml, Zr_m, 1,
173 Yml, Yrl, Zm_r, 1,
174 Yi0, Yrl, Zclr, 1,
175 Yi32, Yrl, Zil_rp, 1,
176 Yi32, Yml, Zilo_m, 2,
177 Yml, Ymr, Zm_r_xm, 1, // MMX MOVD
178 Ymr, Yml, Zr_m_xm, 1, // MMX MOVD
179 Yml, Yxr, Zm_r_xm, 2, // XMM MOVD (32 bit)
180 Yxr, Yml, Zr_m_xm, 2, // XMM MOVD (32 bit)
181 Yiauto, Yrl, Zaut_r, 2,
182 0
183 };
184 uchar yret[] =
185 {
186 Ynone, Ynone, Zo_iw, 1,
187 Yi32, Ynone, Zo_iw, 1,
188 0
189 };
190 uchar ymovq[] =
191 {
192 Yrl, Yml, Zr_m, 1, // 0x89
193 Yml, Yrl, Zm_r, 1, // 0x8b
194 Yi0, Yrl, Zclr, 1, // 0x31
195 Ys32, Yrl, Zilo_m, 2, // 32 bit signed 0xc7,(0)
196 Yi64, Yrl, Ziq_rp, 1, // 0xb8 -- 32/64 bit immediate
197 Yi32, Yml, Zilo_m, 2, // 0xc7,(0)
198 Ym, Ymr, Zm_r_xm_nr, 1, // MMX MOVQ (shorter encoding)
199 Ymr, Ym, Zr_m_xm_nr, 1, // MMX MOVQ
200 Ymm, Ymr, Zm_r_xm, 1, // MMX MOVD
201 Ymr, Ymm, Zr_m_xm, 1, // MMX MOVD
202 Yxr, Ymr, Zm_r_xm_nr, 2, // MOVDQ2Q
203 Yxr, Ym, Zr_m_xm_nr, 2, // MOVQ xmm store
204 Yml, Yxr, Zm_r_xm, 2, // MOVD xmm load
205 Yxr, Yml, Zr_m_xm, 2, // MOVD xmm store
206 Yiauto, Yrl, Zaut_r, 2, // built-in LEAQ
207 0
208 };
209 uchar ym_rl[] =
210 {
211 Ym, Yrl, Zm_r, 1,
212 0
213 };
214 uchar yrl_m[] =
215 {
216 Yrl, Ym, Zr_m, 1,
217 0
218 };
219 uchar ymb_rl[] =
220 {
221 Ymb, Yrl, Zmb_r, 1,
222 0
223 };
224 uchar yml_rl[] =
225 {
226 Yml, Yrl, Zm_r, 1,
227 0
228 };
229 uchar yrl_ml[] =
230 {
231 Yrl, Yml, Zr_m, 1,
232 0
233 };
234 uchar yml_mb[] =
235 {
236 Yrb, Ymb, Zr_m, 1,
237 Ymb, Yrb, Zm_r, 1,
238 0
239 };
240 uchar yrb_mb[] =
241 {
242 Yrb, Ymb, Zr_m, 1,
243 0
244 };
245 uchar yml_ml[] =
246 {
247 Yrl, Yml, Zr_m, 1,
248 Yml, Yrl, Zm_r, 1,
249 0
250 };
251 uchar ydivl[] =
252 {
253 Yml, Ynone, Zm_o, 2,
254 0
255 };
256 uchar ydivb[] =
257 {
258 Ymb, Ynone, Zm_o, 2,
259 0
260 };
261 uchar yimul[] =
262 {
263 Yml, Ynone, Zm_o, 2,
264 Yi8, Yrl, Zib_rr, 1,
265 Yi32, Yrl, Zil_rr, 1,
266 Yml, Yrl, Zm_r, 2,
267 0
268 };
269 uchar ybyte[] =
270 {
271 Yi64, Ynone, Zbyte, 1,
272 0
273 };
274 uchar yin[] =
275 {
276 Yi32, Ynone, Zib_, 1,
277 Ynone, Ynone, Zlit, 1,
278 0
279 };
280 uchar yint[] =
281 {
282 Yi32, Ynone, Zib_, 1,
283 0
284 };
285 uchar ypushl[] =
286 {
287 Yrl, Ynone, Zrp_, 1,
288 Ym, Ynone, Zm_o, 2,
289 Yi8, Ynone, Zib_, 1,
290 Yi32, Ynone, Zil_, 1,
291 0
292 };
293 uchar ypopl[] =
294 {
295 Ynone, Yrl, Z_rp, 1,
296 Ynone, Ym, Zo_m, 2,
297 0
298 };
299 uchar yscond[] =
300 {
301 Ynone, Ymb, Zo_m, 2,
302 0
303 };
304 uchar yjcond[] =
305 {
306 Ynone, Ybr, Zbr, 1,
307 0
308 };
309 uchar yloop[] =
310 {
311 Ynone, Ybr, Zloop, 1,
312 0
313 };
314 uchar ycall[] =
315 {
316 Ynone, Yml, Zo_m64, 2,
317 Ynone, Ybr, Zcall, 1,
318 0
319 };
320 uchar yjmp[] =
321 {
322 Ynone, Yml, Zo_m64, 2,
323 Ynone, Ybr, Zjmp, 1,
324 0
325 };
326
327 uchar yfmvd[] =
328 {
329 Ym, Yf0, Zm_o, 2,
330 Yf0, Ym, Zo_m, 2,
331 Yrf, Yf0, Zm_o, 2,
332 Yf0, Yrf, Zo_m, 2,
333 0
334 };
335 uchar yfmvdp[] =
336 {
337 Yf0, Ym, Zo_m, 2,
338 Yf0, Yrf, Zo_m, 2,
339 0
340 };
341 uchar yfmvf[] =
342 {
343 Ym, Yf0, Zm_o, 2,
344 Yf0, Ym, Zo_m, 2,
345 0
346 };
347 uchar yfmvx[] =
348 {
349 Ym, Yf0, Zm_o, 2,
350 0
351 };
352 uchar yfmvp[] =
353 {
354 Yf0, Ym, Zo_m, 2,
355 0
356 };
357 uchar yfadd[] =
358 {
359 Ym, Yf0, Zm_o, 2,
360 Yrf, Yf0, Zm_o, 2,
361 Yf0, Yrf, Zo_m, 2,
362 0
363 };
364 uchar yfaddp[] =
365 {
366 Yf0, Yrf, Zo_m, 2,
367 0
368 };
369 uchar yfxch[] =
370 {
371 Yf0, Yrf, Zo_m, 2,
372 Yrf, Yf0, Zm_o, 2,
373 0
374 };
375 uchar ycompp[] =
376 {
377 Yf0, Yrf, Zo_m, 2, /* botch is really f0,f1 */
378 0
379 };
380 uchar ystsw[] =
381 {
382 Ynone, Ym, Zo_m, 2,
383 Ynone, Yax, Zlit, 1,
384 0
385 };
386 uchar ystcw[] =
387 {
388 Ynone, Ym, Zo_m, 2,
389 Ym, Ynone, Zm_o, 2,
390 0
391 };
392 uchar ysvrs[] =
393 {
394 Ynone, Ym, Zo_m, 2,
395 Ym, Ynone, Zm_o, 2,
396 0
397 };
398 uchar ymm[] =
399 {
400 Ymm, Ymr, Zm_r_xm, 1,
401 Yxm, Yxr, Zm_r_xm, 2,
402 0
403 };
404 uchar yxm[] =
405 {
406 Yxm, Yxr, Zm_r_xm, 1,
407 0
408 };
409 uchar yxcvm1[] =
410 {
411 Yxm, Yxr, Zm_r_xm, 2,
412 Yxm, Ymr, Zm_r_xm, 2,
413 0
414 };
415 uchar yxcvm2[] =
416 {
417 Yxm, Yxr, Zm_r_xm, 2,
418 Ymm, Yxr, Zm_r_xm, 2,
419 0
420 };
421 uchar yxmq[] =
422 {
423 Yxm, Yxr, Zm_r_xm, 2,
424 0
425 };
426 uchar yxr[] =
427 {
428 Yxr, Yxr, Zm_r_xm, 1,
429 0
430 };
431 uchar yxr_ml[] =
432 {
433 Yxr, Yml, Zr_m_xm, 1,
434 0
435 };
436 uchar ymr[] =
437 {
438 Ymr, Ymr, Zm_r, 1,
439 0
440 };
441 uchar ymr_ml[] =
442 {
443 Ymr, Yml, Zr_m_xm, 1,
444 0
445 };
446 uchar yxcmp[] =
447 {
448 Yxm, Yxr, Zm_r_xm, 1,
449 0
450 };
451 uchar yxcmpi[] =
452 {
453 Yxm, Yxr, Zm_r_i_xm, 2,
454 0
455 };
456 uchar yxmov[] =
457 {
458 Yxm, Yxr, Zm_r_xm, 1,
459 Yxr, Yxm, Zr_m_xm, 1,
460 0
461 };
462 uchar yxcvfl[] =
463 {
464 Yxm, Yrl, Zm_r_xm, 1,
465 0
466 };
467 uchar yxcvlf[] =
468 {
469 Yml, Yxr, Zm_r_xm, 1,
470 0
471 };
472 uchar yxcvfq[] =
473 {
474 Yxm, Yrl, Zm_r_xm, 2,
475 0
476 };
477 uchar yxcvqf[] =
478 {
479 Yml, Yxr, Zm_r_xm, 2,
480 0
481 };
482 uchar yps[] =
483 {
484 Ymm, Ymr, Zm_r_xm, 1,
485 Yi8, Ymr, Zibo_m_xm, 2,
486 Yxm, Yxr, Zm_r_xm, 2,
487 Yi8, Yxr, Zibo_m_xm, 3,
488 0
489 };
490 uchar yxrrl[] =
491 {
492 Yxr, Yrl, Zm_r, 1,
493 0
494 };
495 uchar ymfp[] =
496 {
497 Ymm, Ymr, Zm_r_3d, 1,
498 0,
499 };
500 uchar ymrxr[] =
501 {
502 Ymr, Yxr, Zm_r, 1,
503 Yxm, Yxr, Zm_r_xm, 1,
504 0
505 };
506 uchar ymshuf[] =
507 {
508 Ymm, Ymr, Zibm_r, 1,
509 0
510 };
511 uchar yxshuf[] =
512 {
513 Yxm, Yxr, Zibm_r, 1,
514 0
515 };
516 uchar yextrw[] =
517 {
518 Yxr, Yrl, Zibm_r, 1,
519 0
520 };
521 uchar ypsdq[] =
522 {
523 Yi8, Yxr, Zibo_m, 2,
524 0
525 };
526 uchar ymskb[] =
527 {
528 Yxr, Yrl, Zm_r_xm, 2,
529 Ymr, Yrl, Zm_r_xm, 1,
530 0
531 };
532 uchar ycrc32l[] =
533 {
534 Yml, Yrl, Zlitm_r, 0,
535 };
536
537 /*
538 * You are doasm, holding in your hand a Prog* with p->as set to, say, ACRC32,
539 * and p->from and p->to as operands (Adr*). The linker scans optab to find
540 * the entry with the given p->as and then looks through the ytable for that
541 * instruction (the second field in the optab struct) for a line whose first
542 * two values match the Ytypes of the p->from and p->to operands. The function
543 * oclass in span.c computes the specific Ytype of an operand and then the set
544 * of more general Ytypes that it satisfies is implied by the ycover table, set
545 * up in instinit. For example, oclass distinguishes the constants 0 and 1
546 * from the more general 8-bit constants, but instinit says
547 *
548 * ycover[Yi0*Ymax + Ys32] = 1;
549 * ycover[Yi1*Ymax + Ys32] = 1;
550 * ycover[Yi8*Ymax + Ys32] = 1;
551 *
552 * which means that Yi0, Yi1, and Yi8 all count as Ys32 (signed 32)
553 * if that's what an instruction can handle.
554 *
555 * In parallel with the scan through the ytable for the appropriate line, there
556 * is a z pointer that starts out pointing at the strange magic byte list in
557 * the Optab struct. With each step past a non-matching ytable line, z
558 * advances by the 4th entry in the line. When a matching line is found, that
559 * z pointer has the extra data to use in laying down the instruction bytes.
560 * The actual bytes laid down are a function of the 3rd entry in the line (that
561 * is, the Ztype) and the z bytes.
562 *
563 * For example, let's look at AADDL. The optab line says:
564 * { AADDL, yaddl, Px, 0x83,(00),0x05,0x81,(00),0x01,0x03 },
565 *
566 * and yaddl says
567 * uchar yaddl[] =
568 * {
569 * Yi8, Yml, Zibo_m, 2,
570 * Yi32, Yax, Zil_, 1,
571 * Yi32, Yml, Zilo_m, 2,
572 * Yrl, Yml, Zr_m, 1,
573 * Yml, Yrl, Zm_r, 1,
574 * 0
575 * };
576 *
577 * so there are 5 possible types of ADDL instruction that can be laid down, and
578 * possible states used to lay them down (Ztype and z pointer, assuming z
579 * points at {0x83,(00),0x05,0x81,(00),0x01,0x03}) are:
580 *
581 * Yi8, Yml -> Zibo_m, z (0x83, 00)
582 * Yi32, Yax -> Zil_, z+2 (0x05)
583 * Yi32, Yml -> Zilo_m, z+2+1 (0x81, 0x00)
584 * Yrl, Yml -> Zr_m, z+2+1+2 (0x01)
585 * Yml, Yrl -> Zm_r, z+2+1+2+1 (0x03)
586 *
587 * The Pconstant in the optab line controls the prefix bytes to emit. That's
588 * relatively straightforward as this program goes.
589 *
590 * The switch on t[2] in doasm implements the various Z cases. Zibo_m, for
591 * example, is an opcode byte (z[0]) then an asmando (which is some kind of
592 * encoded addressing mode for the Yml arg), and then a single immediate byte.
593 * Zilo_m is the same but a long (32-bit) immediate.
594 */
595 Optab optab[] =
596 /* as, ytab, andproto, opcode */
597 {
598 { AXXX },
599 { AAAA, ynone, P32, 0x37 },
600 { AAAD, ynone, P32, 0xd5,0x0a },
601 { AAAM, ynone, P32, 0xd4,0x0a },
602 { AAAS, ynone, P32, 0x3f },
603 { AADCB, yxorb, Pb, 0x14,0x80,(02),0x10,0x10 },
604 { AADCL, yxorl, Px, 0x83,(02),0x15,0x81,(02),0x11,0x13 },
605 { AADCQ, yxorl, Pw, 0x83,(02),0x15,0x81,(02),0x11,0x13 },
606 { AADCW, yxorl, Pe, 0x83,(02),0x15,0x81,(02),0x11,0x13 },
607 { AADDB, yxorb, Pb, 0x04,0x80,(00),0x00,0x02 },
608 { AADDL, yaddl, Px, 0x83,(00),0x05,0x81,(00),0x01,0x03 },
609 { AADDPD, yxm, Pq, 0x58 },
610 { AADDPS, yxm, Pm, 0x58 },
611 { AADDQ, yaddl, Pw, 0x83,(00),0x05,0x81,(00),0x01,0x03 },
612 { AADDSD, yxm, Pf2, 0x58 },
613 { AADDSS, yxm, Pf3, 0x58 },
614 { AADDW, yaddl, Pe, 0x83,(00),0x05,0x81,(00),0x01,0x03 },
615 { AADJSP },
616 { AANDB, yxorb, Pb, 0x24,0x80,(04),0x20,0x22 },
617 { AANDL, yxorl, Px, 0x83,(04),0x25,0x81,(04),0x21,0x23 },
618 { AANDNPD, yxm, Pq, 0x55 },
619 { AANDNPS, yxm, Pm, 0x55 },
620 { AANDPD, yxm, Pq, 0x54 },
621 { AANDPS, yxm, Pq, 0x54 },
622 { AANDQ, yxorl, Pw, 0x83,(04),0x25,0x81,(04),0x21,0x23 },
623 { AANDW, yxorl, Pe, 0x83,(04),0x25,0x81,(04),0x21,0x23 },
624 { AARPL, yrl_ml, P32, 0x63 },
625 { ABOUNDL, yrl_m, P32, 0x62 },
626 { ABOUNDW, yrl_m, Pe, 0x62 },
627 { ABSFL, yml_rl, Pm, 0xbc },
628 { ABSFQ, yml_rl, Pw, 0x0f,0xbc },
629 { ABSFW, yml_rl, Pq, 0xbc },
630 { ABSRL, yml_rl, Pm, 0xbd },
631 { ABSRQ, yml_rl, Pw, 0x0f,0xbd },
632 { ABSRW, yml_rl, Pq, 0xbd },
633 { ABTCL, ybtl, Pm, 0xba,(07),0xbb },
634 { ABTCQ, ybtl, Pw, 0x0f,0xba,(07),0x0f,0xbb },
635 { ABTCW, ybtl, Pq, 0xba,(07),0xbb },
636 { ABTL, ybtl, Pm, 0xba,(04),0xa3 },
637 { ABTQ, ybtl, Pw, 0x0f,0xba,(04),0x0f,0xa3},
638 { ABTRL, ybtl, Pm, 0xba,(06),0xb3 },
639 { ABTRQ, ybtl, Pw, 0x0f,0xba,(06),0x0f,0xb3 },
640 { ABTRW, ybtl, Pq, 0xba,(06),0xb3 },
641 { ABTSL, ybtl, Pm, 0xba,(05),0xab },
642 { ABTSQ, ybtl, Pw, 0x0f,0xba,(05),0x0f,0xab },
643 { ABTSW, ybtl, Pq, 0xba,(05),0xab },
644 { ABTW, ybtl, Pq, 0xba,(04),0xa3 },
645 { ABYTE, ybyte, Px, 1 },
646 { ACALL, ycall, Px, 0xff,(02),0xe8 },
647 { ACDQ, ynone, Px, 0x99 },
648 { ACLC, ynone, Px, 0xf8 },
649 { ACLD, ynone, Px, 0xfc },
650 { ACLI, ynone, Px, 0xfa },
651 { ACLTS, ynone, Pm, 0x06 },
652 { ACMC, ynone, Px, 0xf5 },
653 { ACMOVLCC, yml_rl, Pm, 0x43 },
654 { ACMOVLCS, yml_rl, Pm, 0x42 },
655 { ACMOVLEQ, yml_rl, Pm, 0x44 },
656 { ACMOVLGE, yml_rl, Pm, 0x4d },
657 { ACMOVLGT, yml_rl, Pm, 0x4f },
658 { ACMOVLHI, yml_rl, Pm, 0x47 },
659 { ACMOVLLE, yml_rl, Pm, 0x4e },
660 { ACMOVLLS, yml_rl, Pm, 0x46 },
661 { ACMOVLLT, yml_rl, Pm, 0x4c },
662 { ACMOVLMI, yml_rl, Pm, 0x48 },
663 { ACMOVLNE, yml_rl, Pm, 0x45 },
664 { ACMOVLOC, yml_rl, Pm, 0x41 },
665 { ACMOVLOS, yml_rl, Pm, 0x40 },
666 { ACMOVLPC, yml_rl, Pm, 0x4b },
667 { ACMOVLPL, yml_rl, Pm, 0x49 },
668 { ACMOVLPS, yml_rl, Pm, 0x4a },
669 { ACMOVQCC, yml_rl, Pw, 0x0f,0x43 },
670 { ACMOVQCS, yml_rl, Pw, 0x0f,0x42 },
671 { ACMOVQEQ, yml_rl, Pw, 0x0f,0x44 },
672 { ACMOVQGE, yml_rl, Pw, 0x0f,0x4d },
673 { ACMOVQGT, yml_rl, Pw, 0x0f,0x4f },
674 { ACMOVQHI, yml_rl, Pw, 0x0f,0x47 },
675 { ACMOVQLE, yml_rl, Pw, 0x0f,0x4e },
676 { ACMOVQLS, yml_rl, Pw, 0x0f,0x46 },
677 { ACMOVQLT, yml_rl, Pw, 0x0f,0x4c },
678 { ACMOVQMI, yml_rl, Pw, 0x0f,0x48 },
679 { ACMOVQNE, yml_rl, Pw, 0x0f,0x45 },
680 { ACMOVQOC, yml_rl, Pw, 0x0f,0x41 },
681 { ACMOVQOS, yml_rl, Pw, 0x0f,0x40 },
682 { ACMOVQPC, yml_rl, Pw, 0x0f,0x4b },
683 { ACMOVQPL, yml_rl, Pw, 0x0f,0x49 },
684 { ACMOVQPS, yml_rl, Pw, 0x0f,0x4a },
685 { ACMOVWCC, yml_rl, Pq, 0x43 },
686 { ACMOVWCS, yml_rl, Pq, 0x42 },
687 { ACMOVWEQ, yml_rl, Pq, 0x44 },
688 { ACMOVWGE, yml_rl, Pq, 0x4d },
689 { ACMOVWGT, yml_rl, Pq, 0x4f },
690 { ACMOVWHI, yml_rl, Pq, 0x47 },
691 { ACMOVWLE, yml_rl, Pq, 0x4e },
692 { ACMOVWLS, yml_rl, Pq, 0x46 },
693 { ACMOVWLT, yml_rl, Pq, 0x4c },
694 { ACMOVWMI, yml_rl, Pq, 0x48 },
695 { ACMOVWNE, yml_rl, Pq, 0x45 },
696 { ACMOVWOC, yml_rl, Pq, 0x41 },
697 { ACMOVWOS, yml_rl, Pq, 0x40 },
698 { ACMOVWPC, yml_rl, Pq, 0x4b },
699 { ACMOVWPL, yml_rl, Pq, 0x49 },
700 { ACMOVWPS, yml_rl, Pq, 0x4a },
701 { ACMPB, ycmpb, Pb, 0x3c,0x80,(07),0x38,0x3a },
702 { ACMPL, ycmpl, Px, 0x83,(07),0x3d,0x81,(07),0x39,0x3b },
703 { ACMPPD, yxcmpi, Px, Pe,0xc2 },
704 { ACMPPS, yxcmpi, Pm, 0xc2,0 },
705 { ACMPQ, ycmpl, Pw, 0x83,(07),0x3d,0x81,(07),0x39,0x3b },
706 { ACMPSB, ynone, Pb, 0xa6 },
707 { ACMPSD, yxcmpi, Px, Pf2,0xc2 },
708 { ACMPSL, ynone, Px, 0xa7 },
709 { ACMPSQ, ynone, Pw, 0xa7 },
710 { ACMPSS, yxcmpi, Px, Pf3,0xc2 },
711 { ACMPSW, ynone, Pe, 0xa7 },
712 { ACMPW, ycmpl, Pe, 0x83,(07),0x3d,0x81,(07),0x39,0x3b },
713 { ACOMISD, yxcmp, Pe, 0x2f },
714 { ACOMISS, yxcmp, Pm, 0x2f },
715 { ACPUID, ynone, Pm, 0xa2 },
716 { ACVTPL2PD, yxcvm2, Px, Pf3,0xe6,Pe,0x2a },
717 { ACVTPL2PS, yxcvm2, Pm, 0x5b,0,0x2a,0, },
718 { ACVTPD2PL, yxcvm1, Px, Pf2,0xe6,Pe,0x2d },
719 { ACVTPD2PS, yxm, Pe, 0x5a },
720 { ACVTPS2PL, yxcvm1, Px, Pe,0x5b,Pm,0x2d },
721 { ACVTPS2PD, yxm, Pm, 0x5a },
722 { API2FW, ymfp, Px, 0x0c },
723 { ACVTSD2SL, yxcvfl, Pf2, 0x2d },
724 { ACVTSD2SQ, yxcvfq, Pw, Pf2,0x2d },
725 { ACVTSD2SS, yxm, Pf2, 0x5a },
726 { ACVTSL2SD, yxcvlf, Pf2, 0x2a },
727 { ACVTSQ2SD, yxcvqf, Pw, Pf2,0x2a },
728 { ACVTSL2SS, yxcvlf, Pf3, 0x2a },
729 { ACVTSQ2SS, yxcvqf, Pw, Pf3,0x2a },
730 { ACVTSS2SD, yxm, Pf3, 0x5a },
731 { ACVTSS2SL, yxcvfl, Pf3, 0x2d },
732 { ACVTSS2SQ, yxcvfq, Pw, Pf3,0x2d },
733 { ACVTTPD2PL, yxcvm1, Px, Pe,0xe6,Pe,0x2c },
734 { ACVTTPS2PL, yxcvm1, Px, Pf3,0x5b,Pm,0x2c },
735 { ACVTTSD2SL, yxcvfl, Pf2, 0x2c },
736 { ACVTTSD2SQ, yxcvfq, Pw, Pf2,0x2c },
737 { ACVTTSS2SL, yxcvfl, Pf3, 0x2c },
738 { ACVTTSS2SQ, yxcvfq, Pw, Pf3,0x2c },
739 { ACWD, ynone, Pe, 0x99 },
740 { ACQO, ynone, Pw, 0x99 },
741 { ADAA, ynone, P32, 0x27 },
742 { ADAS, ynone, P32, 0x2f },
743 { ADATA },
744 { ADECB, yincb, Pb, 0xfe,(01) },
745 { ADECL, yincl, Px, 0xff,(01) },
746 { ADECQ, yincl, Pw, 0xff,(01) },
747 { ADECW, yincw, Pe, 0xff,(01) },
748 { ADIVB, ydivb, Pb, 0xf6,(06) },
749 { ADIVL, ydivl, Px, 0xf7,(06) },
750 { ADIVPD, yxm, Pe, 0x5e },
751 { ADIVPS, yxm, Pm, 0x5e },
752 { ADIVQ, ydivl, Pw, 0xf7,(06) },
753 { ADIVSD, yxm, Pf2, 0x5e },
754 { ADIVSS, yxm, Pf3, 0x5e },
755 { ADIVW, ydivl, Pe, 0xf7,(06) },
756 { AEMMS, ynone, Pm, 0x77 },
757 { AENTER }, /* botch */
758 { AFXRSTOR, ysvrs, Pm, 0xae,(01),0xae,(01) },
759 { AFXSAVE, ysvrs, Pm, 0xae,(00),0xae,(00) },
760 { AFXRSTOR64, ysvrs, Pw, 0x0f,0xae,(01),0x0f,0xae,(01) },
761 { AFXSAVE64, ysvrs, Pw, 0x0f,0xae,(00),0x0f,0xae,(00) },
762 { AGLOBL },
763 { AGOK },
764 { AHISTORY },
765 { AHLT, ynone, Px, 0xf4 },
766 { AIDIVB, ydivb, Pb, 0xf6,(07) },
767 { AIDIVL, ydivl, Px, 0xf7,(07) },
768 { AIDIVQ, ydivl, Pw, 0xf7,(07) },
769 { AIDIVW, ydivl, Pe, 0xf7,(07) },
770 { AIMULB, ydivb, Pb, 0xf6,(05) },
771 { AIMULL, yimul, Px, 0xf7,(05),0x6b,0x69,Pm,0xaf },
772 { AIMULQ, yimul, Pw, 0xf7,(05),0x6b,0x69,Pm,0xaf },
773 { AIMULW, yimul, Pe, 0xf7,(05),0x6b,0x69,Pm,0xaf },
774 { AINB, yin, Pb, 0xe4,0xec },
775 { AINCB, yincb, Pb, 0xfe,(00) },
776 { AINCL, yincl, Px, 0xff,(00) },
777 { AINCQ, yincl, Pw, 0xff,(00) },
778 { AINCW, yincw, Pe, 0xff,(00) },
779 { AINL, yin, Px, 0xe5,0xed },
780 { AINSB, ynone, Pb, 0x6c },
781 { AINSL, ynone, Px, 0x6d },
782 { AINSW, ynone, Pe, 0x6d },
783 { AINT, yint, Px, 0xcd },
784 { AINTO, ynone, P32, 0xce },
785 { AINW, yin, Pe, 0xe5,0xed },
786 { AIRETL, ynone, Px, 0xcf },
787 { AIRETQ, ynone, Pw, 0xcf },
788 { AIRETW, ynone, Pe, 0xcf },
789 { AJCC, yjcond, Px, 0x73,0x83,(00) },
790 { AJCS, yjcond, Px, 0x72,0x82 },
791 { AJCXZ, yloop, Px, 0xe3 },
792 { AJEQ, yjcond, Px, 0x74,0x84 },
793 { AJGE, yjcond, Px, 0x7d,0x8d },
794 { AJGT, yjcond, Px, 0x7f,0x8f },
795 { AJHI, yjcond, Px, 0x77,0x87 },
796 { AJLE, yjcond, Px, 0x7e,0x8e },
797 { AJLS, yjcond, Px, 0x76,0x86 },
798 { AJLT, yjcond, Px, 0x7c,0x8c },
799 { AJMI, yjcond, Px, 0x78,0x88 },
800 { AJMP, yjmp, Px, 0xff,(04),0xeb,0xe9 },
801 { AJNE, yjcond, Px, 0x75,0x85 },
802 { AJOC, yjcond, Px, 0x71,0x81,(00) },
803 { AJOS, yjcond, Px, 0x70,0x80,(00) },
804 { AJPC, yjcond, Px, 0x7b,0x8b },
805 { AJPL, yjcond, Px, 0x79,0x89 },
806 { AJPS, yjcond, Px, 0x7a,0x8a },
807 { ALAHF, ynone, Px, 0x9f },
808 { ALARL, yml_rl, Pm, 0x02 },
809 { ALARW, yml_rl, Pq, 0x02 },
810 { ALDMXCSR, ysvrs, Pm, 0xae,(02),0xae,(02) },
811 { ALEAL, ym_rl, Px, 0x8d },
812 { ALEAQ, ym_rl, Pw, 0x8d },
813 { ALEAVEL, ynone, P32, 0xc9 },
814 { ALEAVEQ, ynone, Py, 0xc9 },
815 { ALEAVEW, ynone, Pe, 0xc9 },
816 { ALEAW, ym_rl, Pe, 0x8d },
817 { ALOCK, ynone, Px, 0xf0 },
818 { ALODSB, ynone, Pb, 0xac },
819 { ALODSL, ynone, Px, 0xad },
820 { ALODSQ, ynone, Pw, 0xad },
821 { ALODSW, ynone, Pe, 0xad },
822 { ALONG, ybyte, Px, 4 },
823 { ALOOP, yloop, Px, 0xe2 },
824 { ALOOPEQ, yloop, Px, 0xe1 },
825 { ALOOPNE, yloop, Px, 0xe0 },
826 { ALSLL, yml_rl, Pm, 0x03 },
827 { ALSLW, yml_rl, Pq, 0x03 },
828 { AMASKMOVOU, yxr, Pe, 0xf7 },
829 { AMASKMOVQ, ymr, Pm, 0xf7 },
830 { AMAXPD, yxm, Pe, 0x5f },
831 { AMAXPS, yxm, Pm, 0x5f },
832 { AMAXSD, yxm, Pf2, 0x5f },
833 { AMAXSS, yxm, Pf3, 0x5f },
834 { AMINPD, yxm, Pe, 0x5d },
835 { AMINPS, yxm, Pm, 0x5d },
836 { AMINSD, yxm, Pf2, 0x5d },
837 { AMINSS, yxm, Pf3, 0x5d },
838 { AMOVAPD, yxmov, Pe, 0x28,0x29 },
839 { AMOVAPS, yxmov, Pm, 0x28,0x29 },
840 { AMOVB, ymovb, Pb, 0x88,0x8a,0xb0,0xc6,(00) },
841 { AMOVBLSX, ymb_rl, Pm, 0xbe },
842 { AMOVBLZX, ymb_rl, Pm, 0xb6 },
843 { AMOVBQSX, ymb_rl, Pw, 0x0f,0xbe },
844 { AMOVBQZX, ymb_rl, Pw, 0x0f,0xb6 },
845 { AMOVBWSX, ymb_rl, Pq, 0xbe },
846 { AMOVBWZX, ymb_rl, Pq, 0xb6 },
847 { AMOVO, yxmov, Pe, 0x6f,0x7f },
848 { AMOVOU, yxmov, Pf3, 0x6f,0x7f },
849 { AMOVHLPS, yxr, Pm, 0x12 },
850 { AMOVHPD, yxmov, Pe, 0x16,0x17 },
851 { AMOVHPS, yxmov, Pm, 0x16,0x17 },
852 { AMOVL, ymovl, Px, 0x89,0x8b,0x31,0xb8,0xc7,(00),0x6e,0x7e,Pe,0x6e,Pe,0x7e },
853 { AMOVLHPS, yxr, Pm, 0x16 },
854 { AMOVLPD, yxmov, Pe, 0x12,0x13 },
855 { AMOVLPS, yxmov, Pm, 0x12,0x13 },
856 { AMOVLQSX, yml_rl, Pw, 0x63 },
857 { AMOVLQZX, yml_rl, Px, 0x8b },
858 { AMOVMSKPD, yxrrl, Pq, 0x50 },
859 { AMOVMSKPS, yxrrl, Pm, 0x50 },
860 { AMOVNTO, yxr_ml, Pe, 0xe7 },
861 { AMOVNTPD, yxr_ml, Pe, 0x2b },
862 { AMOVNTPS, yxr_ml, Pm, 0x2b },
863 { AMOVNTQ, ymr_ml, Pm, 0xe7 },
864 { AMOVQ, ymovq, Pw, 0x89,0x8b,0x31,0xc7,(00),0xb8,0xc7,(00),0x6f,0x7f,0x6e,0x7e,Pf2,0xd6,Pe,0xd6,Pe,0x6e,Pe,0x7e },
865 { AMOVQOZX, ymrxr, Pf3, 0xd6,0x7e },
866 { AMOVSB, ynone, Pb, 0xa4 },
867 { AMOVSD, yxmov, Pf2, 0x10,0x11 },
868 { AMOVSL, ynone, Px, 0xa5 },
869 { AMOVSQ, ynone, Pw, 0xa5 },
870 { AMOVSS, yxmov, Pf3, 0x10,0x11 },
871 { AMOVSW, ynone, Pe, 0xa5 },
872 { AMOVUPD, yxmov, Pe, 0x10,0x11 },
873 { AMOVUPS, yxmov, Pm, 0x10,0x11 },
874 { AMOVW, ymovw, Pe, 0x89,0x8b,0x31,0xb8,0xc7,(00) },
875 { AMOVWLSX, yml_rl, Pm, 0xbf },
876 { AMOVWLZX, yml_rl, Pm, 0xb7 },
877 { AMOVWQSX, yml_rl, Pw, 0x0f,0xbf },
878 { AMOVWQZX, yml_rl, Pw, 0x0f,0xb7 },
879 { AMULB, ydivb, Pb, 0xf6,(04) },
880 { AMULL, ydivl, Px, 0xf7,(04) },
881 { AMULPD, yxm, Pe, 0x59 },
882 { AMULPS, yxm, Ym, 0x59 },
883 { AMULQ, ydivl, Pw, 0xf7,(04) },
884 { AMULSD, yxm, Pf2, 0x59 },
885 { AMULSS, yxm, Pf3, 0x59 },
886 { AMULW, ydivl, Pe, 0xf7,(04) },
887 { ANAME },
888 { ANEGB, yscond, Pb, 0xf6,(03) },
889 { ANEGL, yscond, Px, 0xf7,(03) },
890 { ANEGQ, yscond, Pw, 0xf7,(03) },
891 { ANEGW, yscond, Pe, 0xf7,(03) },
892 { ANOP, ynop, Px, 0,0 },
893 { ANOTB, yscond, Pb, 0xf6,(02) },
894 { ANOTL, yscond, Px, 0xf7,(02) },
895 { ANOTQ, yscond, Pw, 0xf7,(02) },
896 { ANOTW, yscond, Pe, 0xf7,(02) },
897 { AORB, yxorb, Pb, 0x0c,0x80,(01),0x08,0x0a },
898 { AORL, yxorl, Px, 0x83,(01),0x0d,0x81,(01),0x09,0x0b },
899 { AORPD, yxm, Pq, 0x56 },
900 { AORPS, yxm, Pm, 0x56 },
901 { AORQ, yxorl, Pw, 0x83,(01),0x0d,0x81,(01),0x09,0x0b },
902 { AORW, yxorl, Pe, 0x83,(01),0x0d,0x81,(01),0x09,0x0b },
903 { AOUTB, yin, Pb, 0xe6,0xee },
904 { AOUTL, yin, Px, 0xe7,0xef },
905 { AOUTSB, ynone, Pb, 0x6e },
906 { AOUTSL, ynone, Px, 0x6f },
907 { AOUTSW, ynone, Pe, 0x6f },
908 { AOUTW, yin, Pe, 0xe7,0xef },
909 { APACKSSLW, ymm, Py, 0x6b,Pe,0x6b },
910 { APACKSSWB, ymm, Py, 0x63,Pe,0x63 },
911 { APACKUSWB, ymm, Py, 0x67,Pe,0x67 },
912 { APADDB, ymm, Py, 0xfc,Pe,0xfc },
913 { APADDL, ymm, Py, 0xfe,Pe,0xfe },
914 { APADDQ, yxm, Pe, 0xd4 },
915 { APADDSB, ymm, Py, 0xec,Pe,0xec },
916 { APADDSW, ymm, Py, 0xed,Pe,0xed },
917 { APADDUSB, ymm, Py, 0xdc,Pe,0xdc },
918 { APADDUSW, ymm, Py, 0xdd,Pe,0xdd },
919 { APADDW, ymm, Py, 0xfd,Pe,0xfd },
920 { APAND, ymm, Py, 0xdb,Pe,0xdb },
921 { APANDN, ymm, Py, 0xdf,Pe,0xdf },
922 { APAUSE, ynone, Px, 0xf3,0x90 },
923 { APAVGB, ymm, Py, 0xe0,Pe,0xe0 },
924 { APAVGW, ymm, Py, 0xe3,Pe,0xe3 },
925 { APCMPEQB, ymm, Py, 0x74,Pe,0x74 },
926 { APCMPEQL, ymm, Py, 0x76,Pe,0x76 },
927 { APCMPEQW, ymm, Py, 0x75,Pe,0x75 },
928 { APCMPGTB, ymm, Py, 0x64,Pe,0x64 },
929 { APCMPGTL, ymm, Py, 0x66,Pe,0x66 },
930 { APCMPGTW, ymm, Py, 0x65,Pe,0x65 },
931 { APEXTRW, yextrw, Pq, 0xc5 },
932 { APF2IL, ymfp, Px, 0x1d },
933 { APF2IW, ymfp, Px, 0x1c },
934 { API2FL, ymfp, Px, 0x0d },
935 { APFACC, ymfp, Px, 0xae },
936 { APFADD, ymfp, Px, 0x9e },
937 { APFCMPEQ, ymfp, Px, 0xb0 },
938 { APFCMPGE, ymfp, Px, 0x90 },
939 { APFCMPGT, ymfp, Px, 0xa0 },
940 { APFMAX, ymfp, Px, 0xa4 },
941 { APFMIN, ymfp, Px, 0x94 },
942 { APFMUL, ymfp, Px, 0xb4 },
943 { APFNACC, ymfp, Px, 0x8a },
944 { APFPNACC, ymfp, Px, 0x8e },
945 { APFRCP, ymfp, Px, 0x96 },
946 { APFRCPIT1, ymfp, Px, 0xa6 },
947 { APFRCPI2T, ymfp, Px, 0xb6 },
948 { APFRSQIT1, ymfp, Px, 0xa7 },
949 { APFRSQRT, ymfp, Px, 0x97 },
950 { APFSUB, ymfp, Px, 0x9a },
951 { APFSUBR, ymfp, Px, 0xaa },
952 { APINSRW, yextrw, Pq, 0xc4 },
953 { APMADDWL, ymm, Py, 0xf5,Pe,0xf5 },
954 { APMAXSW, yxm, Pe, 0xee },
955 { APMAXUB, yxm, Pe, 0xde },
956 { APMINSW, yxm, Pe, 0xea },
957 { APMINUB, yxm, Pe, 0xda },
958 { APMOVMSKB, ymskb, Px, Pe,0xd7,0xd7 },
959 { APMULHRW, ymfp, Px, 0xb7 },
960 { APMULHUW, ymm, Py, 0xe4,Pe,0xe4 },
961 { APMULHW, ymm, Py, 0xe5,Pe,0xe5 },
962 { APMULLW, ymm, Py, 0xd5,Pe,0xd5 },
963 { APMULULQ, ymm, Py, 0xf4,Pe,0xf4 },
964 { APOPAL, ynone, P32, 0x61 },
965 { APOPAW, ynone, Pe, 0x61 },
966 { APOPFL, ynone, P32, 0x9d },
967 { APOPFQ, ynone, Py, 0x9d },
968 { APOPFW, ynone, Pe, 0x9d },
969 { APOPL, ypopl, P32, 0x58,0x8f,(00) },
970 { APOPQ, ypopl, Py, 0x58,0x8f,(00) },
971 { APOPW, ypopl, Pe, 0x58,0x8f,(00) },
972 { APOR, ymm, Py, 0xeb,Pe,0xeb },
973 { APSADBW, yxm, Pq, 0xf6 },
974 { APSHUFHW, yxshuf, Pf3, 0x70 },
975 { APSHUFL, yxshuf, Pq, 0x70 },
976 { APSHUFLW, yxshuf, Pf2, 0x70 },
977 { APSHUFW, ymshuf, Pm, 0x70 },
978 { APSLLO, ypsdq, Pq, 0x73,(07) },
979 { APSLLL, yps, Py, 0xf2, 0x72,(06), Pe,0xf2, Pe,0x72,(06) },
980 { APSLLQ, yps, Py, 0xf3, 0x73,(06), Pe,0xf3, Pe,0x7e,(06) },
981 { APSLLW, yps, Py, 0xf1, 0x71,(06), Pe,0xf1, Pe,0x71,(06) },
982 { APSRAL, yps, Py, 0xe2, 0x72,(04), Pe,0xe2, Pe,0x72,(04) },
983 { APSRAW, yps, Py, 0xe1, 0x71,(04), Pe,0xe1, Pe,0x71,(04) },
984 { APSRLO, ypsdq, Pq, 0x73,(03) },
985 { APSRLL, yps, Py, 0xd2, 0x72,(02), Pe,0xd2, Pe,0x72,(02) },
986 { APSRLQ, yps, Py, 0xd3, 0x73,(02), Pe,0xd3, Pe,0x73,(02) },
987 { APSRLW, yps, Py, 0xd1, 0x71,(02), Pe,0xe1, Pe,0x71,(02) },
988 { APSUBB, yxm, Pe, 0xf8 },
989 { APSUBL, yxm, Pe, 0xfa },
990 { APSUBQ, yxm, Pe, 0xfb },
991 { APSUBSB, yxm, Pe, 0xe8 },
992 { APSUBSW, yxm, Pe, 0xe9 },
993 { APSUBUSB, yxm, Pe, 0xd8 },
994 { APSUBUSW, yxm, Pe, 0xd9 },
995 { APSUBW, yxm, Pe, 0xf9 },
996 { APSWAPL, ymfp, Px, 0xbb },
997 { APUNPCKHBW, ymm, Py, 0x68,Pe,0x68 },
998 { APUNPCKHLQ, ymm, Py, 0x6a,Pe,0x6a },
999 { APUNPCKHQDQ, yxm, Pe, 0x6d },
1000 { APUNPCKHWL, ymm, Py, 0x69,Pe,0x69 },
1001 { APUNPCKLBW, ymm, Py, 0x60,Pe,0x60 },
1002 { APUNPCKLLQ, ymm, Py, 0x62,Pe,0x62 },
1003 { APUNPCKLQDQ, yxm, Pe, 0x6c },
1004 { APUNPCKLWL, ymm, Py, 0x61,Pe,0x61 },
1005 { APUSHAL, ynone, P32, 0x60 },
1006 { APUSHAW, ynone, Pe, 0x60 },
1007 { APUSHFL, ynone, P32, 0x9c },
1008 { APUSHFQ, ynone, Py, 0x9c },
1009 { APUSHFW, ynone, Pe, 0x9c },
1010 { APUSHL, ypushl, P32, 0x50,0xff,(06),0x6a,0x68 },
1011 { APUSHQ, ypushl, Py, 0x50,0xff,(06),0x6a,0x68 },
1012 { APUSHW, ypushl, Pe, 0x50,0xff,(06),0x6a,0x68 },
1013 { APXOR, ymm, Py, 0xef,Pe,0xef },
1014 { AQUAD, ybyte, Px, 8 },
1015 { ARCLB, yshb, Pb, 0xd0,(02),0xc0,(02),0xd2,(02) },
1016 { ARCLL, yshl, Px, 0xd1,(02),0xc1,(02),0xd3,(02),0xd3,(02) },
1017 { ARCLQ, yshl, Pw, 0xd1,(02),0xc1,(02),0xd3,(02),0xd3,(02) },
1018 { ARCLW, yshl, Pe, 0xd1,(02),0xc1,(02),0xd3,(02),0xd3,(02) },
1019 { ARCPPS, yxm, Pm, 0x53 },
1020 { ARCPSS, yxm, Pf3, 0x53 },
1021 { ARCRB, yshb, Pb, 0xd0,(03),0xc0,(03),0xd2,(03) },
1022 { ARCRL, yshl, Px, 0xd1,(03),0xc1,(03),0xd3,(03),0xd3,(03) },
1023 { ARCRQ, yshl, Pw, 0xd1,(03),0xc1,(03),0xd3,(03),0xd3,(03) },
1024 { ARCRW, yshl, Pe, 0xd1,(03),0xc1,(03),0xd3,(03),0xd3,(03) },
1025 { AREP, ynone, Px, 0xf3 },
1026 { AREPN, ynone, Px, 0xf2 },
1027 { ARET, ynone, Px, 0xc3 },
1028 { ARETFW, yret, Pe, 0xcb,0xca },
1029 { ARETFL, yret, Px, 0xcb,0xca },
1030 { ARETFQ, yret, Pw, 0xcb,0xca },
1031 { AROLB, yshb, Pb, 0xd0,(00),0xc0,(00),0xd2,(00) },
1032 { AROLL, yshl, Px, 0xd1,(00),0xc1,(00),0xd3,(00),0xd3,(00) },
1033 { AROLQ, yshl, Pw, 0xd1,(00),0xc1,(00),0xd3,(00),0xd3,(00) },
1034 { AROLW, yshl, Pe, 0xd1,(00),0xc1,(00),0xd3,(00),0xd3,(00) },
1035 { ARORB, yshb, Pb, 0xd0,(01),0xc0,(01),0xd2,(01) },
1036 { ARORL, yshl, Px, 0xd1,(01),0xc1,(01),0xd3,(01),0xd3,(01) },
1037 { ARORQ, yshl, Pw, 0xd1,(01),0xc1,(01),0xd3,(01),0xd3,(01) },
1038 { ARORW, yshl, Pe, 0xd1,(01),0xc1,(01),0xd3,(01),0xd3,(01) },
1039 { ARSQRTPS, yxm, Pm, 0x52 },
1040 { ARSQRTSS, yxm, Pf3, 0x52 },
1041 { ASAHF, ynone, Px, 0x86,0xe0,0x50,0x9d }, /* XCHGB AH,AL; PUSH AX; POPFL */
1042 { ASALB, yshb, Pb, 0xd0,(04),0xc0,(04),0xd2,(04) },
1043 { ASALL, yshl, Px, 0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04) },
1044 { ASALQ, yshl, Pw, 0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04) },
1045 { ASALW, yshl, Pe, 0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04) },
1046 { ASARB, yshb, Pb, 0xd0,(07),0xc0,(07),0xd2,(07) },
1047 { ASARL, yshl, Px, 0xd1,(07),0xc1,(07),0xd3,(07),0xd3,(07) },
1048 { ASARQ, yshl, Pw, 0xd1,(07),0xc1,(07),0xd3,(07),0xd3,(07) },
1049 { ASARW, yshl, Pe, 0xd1,(07),0xc1,(07),0xd3,(07),0xd3,(07) },
1050 { ASBBB, yxorb, Pb, 0x1c,0x80,(03),0x18,0x1a },
1051 { ASBBL, yxorl, Px, 0x83,(03),0x1d,0x81,(03),0x19,0x1b },
1052 { ASBBQ, yxorl, Pw, 0x83,(03),0x1d,0x81,(03),0x19,0x1b },
1053 { ASBBW, yxorl, Pe, 0x83,(03),0x1d,0x81,(03),0x19,0x1b },
1054 { ASCASB, ynone, Pb, 0xae },
1055 { ASCASL, ynone, Px, 0xaf },
1056 { ASCASQ, ynone, Pw, 0xaf },
1057 { ASCASW, ynone, Pe, 0xaf },
1058 { ASETCC, yscond, Pm, 0x93,(00) },
1059 { ASETCS, yscond, Pm, 0x92,(00) },
1060 { ASETEQ, yscond, Pm, 0x94,(00) },
1061 { ASETGE, yscond, Pm, 0x9d,(00) },
1062 { ASETGT, yscond, Pm, 0x9f,(00) },
1063 { ASETHI, yscond, Pm, 0x97,(00) },
1064 { ASETLE, yscond, Pm, 0x9e,(00) },
1065 { ASETLS, yscond, Pm, 0x96,(00) },
1066 { ASETLT, yscond, Pm, 0x9c,(00) },
1067 { ASETMI, yscond, Pm, 0x98,(00) },
1068 { ASETNE, yscond, Pm, 0x95,(00) },
1069 { ASETOC, yscond, Pm, 0x91,(00) },
1070 { ASETOS, yscond, Pm, 0x90,(00) },
1071 { ASETPC, yscond, Pm, 0x96,(00) },
1072 { ASETPL, yscond, Pm, 0x99,(00) },
1073 { ASETPS, yscond, Pm, 0x9a,(00) },
1074 { ASHLB, yshb, Pb, 0xd0,(04),0xc0,(04),0xd2,(04) },
1075 { ASHLL, yshl, Px, 0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04) },
1076 { ASHLQ, yshl, Pw, 0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04) },
1077 { ASHLW, yshl, Pe, 0xd1,(04),0xc1,(04),0xd3,(04),0xd3,(04) },
1078 { ASHRB, yshb, Pb, 0xd0,(05),0xc0,(05),0xd2,(05) },
1079 { ASHRL, yshl, Px, 0xd1,(05),0xc1,(05),0xd3,(05),0xd3,(05) },
1080 { ASHRQ, yshl, Pw, 0xd1,(05),0xc1,(05),0xd3,(05),0xd3,(05) },
1081 { ASHRW, yshl, Pe, 0xd1,(05),0xc1,(05),0xd3,(05),0xd3,(05) },
1082 { ASHUFPD, yxshuf, Pq, 0xc6 },
1083 { ASHUFPS, yxshuf, Pm, 0xc6 },
1084 { ASQRTPD, yxm, Pe, 0x51 },
1085 { ASQRTPS, yxm, Pm, 0x51 },
1086 { ASQRTSD, yxm, Pf2, 0x51 },
1087 { ASQRTSS, yxm, Pf3, 0x51 },
1088 { ASTC, ynone, Px, 0xf9 },
1089 { ASTD, ynone, Px, 0xfd },
1090 { ASTI, ynone, Px, 0xfb },
1091 { ASTMXCSR, ysvrs, Pm, 0xae,(03),0xae,(03) },
1092 { ASTOSB, ynone, Pb, 0xaa },
1093 { ASTOSL, ynone, Px, 0xab },
1094 { ASTOSQ, ynone, Pw, 0xab },
1095 { ASTOSW, ynone, Pe, 0xab },
1096 { ASUBB, yxorb, Pb, 0x2c,0x80,(05),0x28,0x2a },
1097 { ASUBL, yaddl, Px, 0x83,(05),0x2d,0x81,(05),0x29,0x2b },
1098 { ASUBPD, yxm, Pe, 0x5c },
1099 { ASUBPS, yxm, Pm, 0x5c },
1100 { ASUBQ, yaddl, Pw, 0x83,(05),0x2d,0x81,(05),0x29,0x2b },
1101 { ASUBSD, yxm, Pf2, 0x5c },
1102 { ASUBSS, yxm, Pf3, 0x5c },
1103 { ASUBW, yaddl, Pe, 0x83,(05),0x2d,0x81,(05),0x29,0x2b },
1104 { ASWAPGS, ynone, Pm, 0x01,0xf8 },
1105 { ASYSCALL, ynone, Px, 0x0f,0x05 }, /* fast syscall */
1106 { ATESTB, ytestb, Pb, 0xa8,0xf6,(00),0x84,0x84 },
1107 { ATESTL, ytestl, Px, 0xa9,0xf7,(00),0x85,0x85 },
1108 { ATESTQ, ytestl, Pw, 0xa9,0xf7,(00),0x85,0x85 },
1109 { ATESTW, ytestl, Pe, 0xa9,0xf7,(00),0x85,0x85 },
1110 { ATEXT, ytext, Px },
1111 { AUCOMISD, yxcmp, Pe, 0x2e },
1112 { AUCOMISS, yxcmp, Pm, 0x2e },
1113 { AUNPCKHPD, yxm, Pe, 0x15 },
1114 { AUNPCKHPS, yxm, Pm, 0x15 },
1115 { AUNPCKLPD, yxm, Pe, 0x14 },
1116 { AUNPCKLPS, yxm, Pm, 0x14 },
1117 { AVERR, ydivl, Pm, 0x00,(04) },
1118 { AVERW, ydivl, Pm, 0x00,(05) },
1119 { AWAIT, ynone, Px, 0x9b },
1120 { AWORD, ybyte, Px, 2 },
1121 { AXCHGB, yml_mb, Pb, 0x86,0x86 },
1122 { AXCHGL, yml_ml, Px, 0x87,0x87 },
1123 { AXCHGQ, yml_ml, Pw, 0x87,0x87 },
1124 { AXCHGW, yml_ml, Pe, 0x87,0x87 },
1125 { AXLAT, ynone, Px, 0xd7 },
1126 { AXORB, yxorb, Pb, 0x34,0x80,(06),0x30,0x32 },
1127 { AXORL, yxorl, Px, 0x83,(06),0x35,0x81,(06),0x31,0x33 },
1128 { AXORPD, yxm, Pe, 0x57 },
1129 { AXORPS, yxm, Pm, 0x57 },
1130 { AXORQ, yxorl, Pw, 0x83,(06),0x35,0x81,(06),0x31,0x33 },
1131 { AXORW, yxorl, Pe, 0x83,(06),0x35,0x81,(06),0x31,0x33 },
1132
1133 { AFMOVB, yfmvx, Px, 0xdf,(04) },
1134 { AFMOVBP, yfmvp, Px, 0xdf,(06) },
1135 { AFMOVD, yfmvd, Px, 0xdd,(00),0xdd,(02),0xd9,(00),0xdd,(02) },
1136 { AFMOVDP, yfmvdp, Px, 0xdd,(03),0xdd,(03) },
1137 { AFMOVF, yfmvf, Px, 0xd9,(00),0xd9,(02) },
1138 { AFMOVFP, yfmvp, Px, 0xd9,(03) },
1139 { AFMOVL, yfmvf, Px, 0xdb,(00),0xdb,(02) },
1140 { AFMOVLP, yfmvp, Px, 0xdb,(03) },
1141 { AFMOVV, yfmvx, Px, 0xdf,(05) },
1142 { AFMOVVP, yfmvp, Px, 0xdf,(07) },
1143 { AFMOVW, yfmvf, Px, 0xdf,(00),0xdf,(02) },
1144 { AFMOVWP, yfmvp, Px, 0xdf,(03) },
1145 { AFMOVX, yfmvx, Px, 0xdb,(05) },
1146 { AFMOVXP, yfmvp, Px, 0xdb,(07) },
1147
1148 { AFCOMB },
1149 { AFCOMBP },
1150 { AFCOMD, yfadd, Px, 0xdc,(02),0xd8,(02),0xdc,(02) }, /* botch */
1151 { AFCOMDP, yfadd, Px, 0xdc,(03),0xd8,(03),0xdc,(03) }, /* botch */
1152 { AFCOMDPP, ycompp, Px, 0xde,(03) },
1153 { AFCOMF, yfmvx, Px, 0xd8,(02) },
1154 { AFCOMFP, yfmvx, Px, 0xd8,(03) },
1155 { AFCOML, yfmvx, Px, 0xda,(02) },
1156 { AFCOMLP, yfmvx, Px, 0xda,(03) },
1157 { AFCOMW, yfmvx, Px, 0xde,(02) },
1158 { AFCOMWP, yfmvx, Px, 0xde,(03) },
1159
1160 { AFUCOM, ycompp, Px, 0xdd,(04) },
1161 { AFUCOMP, ycompp, Px, 0xdd,(05) },
1162 { AFUCOMPP, ycompp, Px, 0xda,(13) },
1163
1164 { AFADDDP, yfaddp, Px, 0xde,(00) },
1165 { AFADDW, yfmvx, Px, 0xde,(00) },
1166 { AFADDL, yfmvx, Px, 0xda,(00) },
1167 { AFADDF, yfmvx, Px, 0xd8,(00) },
1168 { AFADDD, yfadd, Px, 0xdc,(00),0xd8,(00),0xdc,(00) },
1169
1170 { AFMULDP, yfaddp, Px, 0xde,(01) },
1171 { AFMULW, yfmvx, Px, 0xde,(01) },
1172 { AFMULL, yfmvx, Px, 0xda,(01) },
1173 { AFMULF, yfmvx, Px, 0xd8,(01) },
1174 { AFMULD, yfadd, Px, 0xdc,(01),0xd8,(01),0xdc,(01) },
1175
1176 { AFSUBDP, yfaddp, Px, 0xde,(05) },
1177 { AFSUBW, yfmvx, Px, 0xde,(04) },
1178 { AFSUBL, yfmvx, Px, 0xda,(04) },
1179 { AFSUBF, yfmvx, Px, 0xd8,(04) },
1180 { AFSUBD, yfadd, Px, 0xdc,(04),0xd8,(04),0xdc,(05) },
1181
1182 { AFSUBRDP, yfaddp, Px, 0xde,(04) },
1183 { AFSUBRW, yfmvx, Px, 0xde,(05) },
1184 { AFSUBRL, yfmvx, Px, 0xda,(05) },
1185 { AFSUBRF, yfmvx, Px, 0xd8,(05) },
1186 { AFSUBRD, yfadd, Px, 0xdc,(05),0xd8,(05),0xdc,(04) },
1187
1188 { AFDIVDP, yfaddp, Px, 0xde,(07) },
1189 { AFDIVW, yfmvx, Px, 0xde,(06) },
1190 { AFDIVL, yfmvx, Px, 0xda,(06) },
1191 { AFDIVF, yfmvx, Px, 0xd8,(06) },
1192 { AFDIVD, yfadd, Px, 0xdc,(06),0xd8,(06),0xdc,(07) },
1193
1194 { AFDIVRDP, yfaddp, Px, 0xde,(06) },
1195 { AFDIVRW, yfmvx, Px, 0xde,(07) },
1196 { AFDIVRL, yfmvx, Px, 0xda,(07) },
1197 { AFDIVRF, yfmvx, Px, 0xd8,(07) },
1198 { AFDIVRD, yfadd, Px, 0xdc,(07),0xd8,(07),0xdc,(06) },
1199
1200 { AFXCHD, yfxch, Px, 0xd9,(01),0xd9,(01) },
1201 { AFFREE },
1202 { AFLDCW, ystcw, Px, 0xd9,(05),0xd9,(05) },
1203 { AFLDENV, ystcw, Px, 0xd9,(04),0xd9,(04) },
1204 { AFRSTOR, ysvrs, Px, 0xdd,(04),0xdd,(04) },
1205 { AFSAVE, ysvrs, Px, 0xdd,(06),0xdd,(06) },
1206 { AFSTCW, ystcw, Px, 0xd9,(07),0xd9,(07) },
1207 { AFSTENV, ystcw, Px, 0xd9,(06),0xd9,(06) },
1208 { AFSTSW, ystsw, Px, 0xdd,(07),0xdf,0xe0 },
1209 { AF2XM1, ynone, Px, 0xd9, 0xf0 },
1210 { AFABS, ynone, Px, 0xd9, 0xe1 },
1211 { AFCHS, ynone, Px, 0xd9, 0xe0 },
1212 { AFCLEX, ynone, Px, 0xdb, 0xe2 },
1213 { AFCOS, ynone, Px, 0xd9, 0xff },
1214 { AFDECSTP, ynone, Px, 0xd9, 0xf6 },
1215 { AFINCSTP, ynone, Px, 0xd9, 0xf7 },
1216 { AFINIT, ynone, Px, 0xdb, 0xe3 },
1217 { AFLD1, ynone, Px, 0xd9, 0xe8 },
1218 { AFLDL2E, ynone, Px, 0xd9, 0xea },
1219 { AFLDL2T, ynone, Px, 0xd9, 0xe9 },
1220 { AFLDLG2, ynone, Px, 0xd9, 0xec },
1221 { AFLDLN2, ynone, Px, 0xd9, 0xed },
1222 { AFLDPI, ynone, Px, 0xd9, 0xeb },
1223 { AFLDZ, ynone, Px, 0xd9, 0xee },
1224 { AFNOP, ynone, Px, 0xd9, 0xd0 },
1225 { AFPATAN, ynone, Px, 0xd9, 0xf3 },
1226 { AFPREM, ynone, Px, 0xd9, 0xf8 },
1227 { AFPREM1, ynone, Px, 0xd9, 0xf5 },
1228 { AFPTAN, ynone, Px, 0xd9, 0xf2 },
1229 { AFRNDINT, ynone, Px, 0xd9, 0xfc },
1230 { AFSCALE, ynone, Px, 0xd9, 0xfd },
1231 { AFSIN, ynone, Px, 0xd9, 0xfe },
1232 { AFSINCOS, ynone, Px, 0xd9, 0xfb },
1233 { AFSQRT, ynone, Px, 0xd9, 0xfa },
1234 { AFTST, ynone, Px, 0xd9, 0xe4 },
1235 { AFXAM, ynone, Px, 0xd9, 0xe5 },
1236 { AFXTRACT, ynone, Px, 0xd9, 0xf4 },
1237 { AFYL2X, ynone, Px, 0xd9, 0xf1 },
1238 { AFYL2XP1, ynone, Px, 0xd9, 0xf9 },
1239
1240 { ACMPXCHGB, yrb_mb, Pb, 0x0f,0xb0 },
1241 { ACMPXCHGL, yrl_ml, Px, 0x0f,0xb1 },
1242 { ACMPXCHGW, yrl_ml, Pe, 0x0f,0xb1 },
1243 { ACMPXCHGQ, yrl_ml, Pw, 0x0f,0xb1 },
1244 { ACMPXCHG8B, yscond, Pm, 0xc7,(01) },
1245 { AINVD, ynone, Pm, 0x08 },
1246 { AINVLPG, ymbs, Pm, 0x01,(07) },
1247 { ALFENCE, ynone, Pm, 0xae,0xe8 },
1248 { AMFENCE, ynone, Pm, 0xae,0xf0 },
1249 { AMOVNTIL, yrl_ml, Pm, 0xc3 },
1250 { AMOVNTIQ, yrl_ml, Pw, 0x0f,0xc3 },
1251 { ARDMSR, ynone, Pm, 0x32 },
1252 { ARDPMC, ynone, Pm, 0x33 },
1253 { ARDTSC, ynone, Pm, 0x31 },
1254 { ARSM, ynone, Pm, 0xaa },
1255 { ASFENCE, ynone, Pm, 0xae,0xf8 },
1256 { ASYSRET, ynone, Pm, 0x07 },
1257 { AWBINVD, ynone, Pm, 0x09 },
1258 { AWRMSR, ynone, Pm, 0x30 },
1259
1260 { AXADDB, yrb_mb, Pb, 0x0f,0xc0 },
1261 { AXADDL, yrl_ml, Px, 0x0f,0xc1 },
1262 { AXADDQ, yrl_ml, Pw, 0x0f,0xc1 },
1263 { AXADDW, yrl_ml, Pe, 0x0f,0xc1 },
1264
1265 { ACRC32B, ycrc32l,Px, 0xf2,0x0f,0x38,0xf0,0},
1266 { ACRC32Q, ycrc32l,Pw, 0xf2,0x0f,0x38,0xf1,0},
1267
1268 { AEND },
1269 0
1270 };
1271
1272 Optab* opindex[ALAST+1];
1273
1274 /*
1275 AMOVD 0f 6e/r mmx,reg/mem32[mem64-rex?]
1276 AMOVD 0f 7e/r reg/mem32[64],mmx STORE
1277 AMOVQ 0f 6f/r mmx1,mmx2/mem64
1278 AMOVQ 0f 7f/r mmx1/mem64,mmx2
1279 */