2 * Copyright (c) 2000-2006 Marcel Moolenaar
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
30 #include <sys/param.h>
31 #include <sys/systm.h>
33 #include <machine/stdarg.h>
35 #include <ia64/disasm/disasm_int.h>
36 #include <ia64/disasm/disasm.h>
38 #define FRAG(o,l) ((int)((o << 8) | (l & 0xff)))
39 #define FRAG_OFS(f) (f >> 8)
40 #define FRAG_LEN(f) (f & 0xff)
46 asm_cmpltr_add(struct asm_inst *i, enum asm_cmpltr_class c,
47 enum asm_cmpltr_type t)
50 i->i_cmpltr[i->i_ncmpltrs].c_class = c;
51 i->i_cmpltr[i->i_ncmpltrs].c_type = t;
53 KASSERT(i->i_ncmpltrs < 6, ("foo"));
57 asm_hint(struct asm_inst *i, enum asm_cmpltr_class c)
60 switch (FIELD(i->i_bits, 28, 2)) { /* hint */
62 asm_cmpltr_add(i, c, ASM_CT_NONE);
65 asm_cmpltr_add(i, c, ASM_CT_NT1);
68 asm_cmpltr_add(i, c, ASM_CT_NT2);
71 asm_cmpltr_add(i, c, ASM_CT_NTA);
77 asm_sf(struct asm_inst *i)
80 switch (FIELD(i->i_bits, 34, 2)) {
82 asm_cmpltr_add(i, ASM_CC_SF, ASM_CT_S0);
85 asm_cmpltr_add(i, ASM_CC_SF, ASM_CT_S1);
88 asm_cmpltr_add(i, ASM_CC_SF, ASM_CT_S2);
91 asm_cmpltr_add(i, ASM_CC_SF, ASM_CT_S3);
97 asm_brhint(struct asm_inst *i)
99 uint64_t bits = i->i_bits;
101 switch (FIELD(bits, 33, 2)) { /* bwh */
103 asm_cmpltr_add(i, ASM_CC_BWH, ASM_CT_SPTK);
106 asm_cmpltr_add(i, ASM_CC_BWH, ASM_CT_SPNT);
109 asm_cmpltr_add(i, ASM_CC_BWH, ASM_CT_DPTK);
112 asm_cmpltr_add(i, ASM_CC_BWH, ASM_CT_DPNT);
116 if (FIELD(bits, 12, 1)) /* ph */
117 asm_cmpltr_add(i, ASM_CC_PH, ASM_CT_MANY);
119 asm_cmpltr_add(i, ASM_CC_PH, ASM_CT_FEW);
121 if (FIELD(bits, 35, 1)) /* dh */
122 asm_cmpltr_add(i, ASM_CC_DH, ASM_CT_CLR);
124 asm_cmpltr_add(i, ASM_CC_DH, ASM_CT_NONE);
128 asm_brphint(struct asm_inst *i)
130 uint64_t bits = i->i_bits;
132 switch (FIELD(bits, 3, 2)) { /* ipwh, indwh */
134 asm_cmpltr_add(i, ASM_CC_IPWH, ASM_CT_SPTK);
137 asm_cmpltr_add(i, ASM_CC_IPWH, ASM_CT_LOOP);
140 asm_cmpltr_add(i, ASM_CC_IPWH, ASM_CT_DPTK);
143 asm_cmpltr_add(i, ASM_CC_IPWH, ASM_CT_EXIT);
147 if (FIELD(bits, 5, 1)) /* ph */
148 asm_cmpltr_add(i, ASM_CC_PH, ASM_CT_MANY);
150 asm_cmpltr_add(i, ASM_CC_PH, ASM_CT_FEW);
152 switch (FIELD(bits, 0, 3)) { /* pvec */
154 asm_cmpltr_add(i, ASM_CC_PVEC, ASM_CT_DC_DC);
157 asm_cmpltr_add(i, ASM_CC_PVEC, ASM_CT_DC_NT);
160 asm_cmpltr_add(i, ASM_CC_PVEC, ASM_CT_TK_DC);
163 asm_cmpltr_add(i, ASM_CC_PVEC, ASM_CT_TK_TK);
166 asm_cmpltr_add(i, ASM_CC_PVEC, ASM_CT_TK_NT);
169 asm_cmpltr_add(i, ASM_CC_PVEC, ASM_CT_NT_DC);
172 asm_cmpltr_add(i, ASM_CC_PVEC, ASM_CT_NT_TK);
175 asm_cmpltr_add(i, ASM_CC_PVEC, ASM_CT_NT_NT);
179 if (FIELD(bits, 35, 1)) /* ih */
180 asm_cmpltr_add(i, ASM_CC_IH, ASM_CT_IMP);
182 asm_cmpltr_add(i, ASM_CC_IH, ASM_CT_NONE);
185 static enum asm_oper_type
186 asm_normalize(struct asm_inst *i, enum asm_op op)
188 enum asm_oper_type ot = ASM_OPER_NONE;
192 asm_cmpltr_add(i, ASM_CC_BTYPE, ASM_CT_CALL);
195 case ASM_OP_BR_CEXIT:
196 asm_cmpltr_add(i, ASM_CC_BTYPE, ASM_CT_CEXIT);
199 case ASM_OP_BR_CLOOP:
200 asm_cmpltr_add(i, ASM_CC_BTYPE, ASM_CT_CLOOP);
204 asm_cmpltr_add(i, ASM_CC_BTYPE, ASM_CT_COND);
208 asm_cmpltr_add(i, ASM_CC_BTYPE, ASM_CT_CTOP);
212 asm_cmpltr_add(i, ASM_CC_BTYPE, ASM_CT_IA);
216 asm_cmpltr_add(i, ASM_CC_BTYPE, ASM_CT_RET);
219 case ASM_OP_BR_WEXIT:
220 asm_cmpltr_add(i, ASM_CC_BTYPE, ASM_CT_WEXIT);
224 asm_cmpltr_add(i, ASM_CC_BTYPE, ASM_CT_WTOP);
228 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_B);
232 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_F);
236 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_I);
240 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_M);
244 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_X);
247 case ASM_OP_BRL_COND:
248 asm_cmpltr_add(i, ASM_CC_BTYPE, ASM_CT_COND);
251 case ASM_OP_BRL_CALL:
252 asm_cmpltr_add(i, ASM_CC_BTYPE, ASM_CT_CALL);
256 asm_cmpltr_add(i, ASM_CC_BTYPE, ASM_CT_NONE);
260 asm_cmpltr_add(i, ASM_CC_BTYPE, ASM_CT_RET);
264 asm_cmpltr_add(i, ASM_CC_BSW, ASM_CT_0);
268 asm_cmpltr_add(i, ASM_CC_BSW, ASM_CT_1);
271 case ASM_OP_CHK_A_CLR:
272 asm_cmpltr_add(i, ASM_CC_CHK, ASM_CT_A);
273 asm_cmpltr_add(i, ASM_CC_ACLR, ASM_CT_CLR);
276 case ASM_OP_CHK_A_NC:
277 asm_cmpltr_add(i, ASM_CC_CHK, ASM_CT_A);
278 asm_cmpltr_add(i, ASM_CC_ACLR, ASM_CT_NC);
282 asm_cmpltr_add(i, ASM_CC_CHK, ASM_CT_S);
286 asm_cmpltr_add(i, ASM_CC_CHK, ASM_CT_S);
287 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_I);
291 asm_cmpltr_add(i, ASM_CC_CHK, ASM_CT_S);
292 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_M);
296 asm_cmpltr_add(i, ASM_CC_CLRRRB, ASM_CT_NONE);
299 case ASM_OP_CLRRRB_PR:
300 asm_cmpltr_add(i, ASM_CC_CLRRRB, ASM_CT_PR);
304 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_EQ);
305 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_NONE);
308 case ASM_OP_CMP_EQ_AND:
309 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_EQ);
310 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
313 case ASM_OP_CMP_EQ_OR:
314 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_EQ);
315 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
318 case ASM_OP_CMP_EQ_OR_ANDCM:
319 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_EQ);
320 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
323 case ASM_OP_CMP_EQ_UNC:
324 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_EQ);
325 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_UNC);
328 case ASM_OP_CMP_GE_AND:
329 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_GE);
330 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
333 case ASM_OP_CMP_GE_OR:
334 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_GE);
335 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
338 case ASM_OP_CMP_GE_OR_ANDCM:
339 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_GE);
340 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
343 case ASM_OP_CMP_GT_AND:
344 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_GT);
345 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
348 case ASM_OP_CMP_GT_OR:
349 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_GT);
350 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
353 case ASM_OP_CMP_GT_OR_ANDCM:
354 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_GT);
355 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
358 case ASM_OP_CMP_LE_AND:
359 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LE);
360 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
363 case ASM_OP_CMP_LE_OR:
364 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LE);
365 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
368 case ASM_OP_CMP_LE_OR_ANDCM:
369 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LE);
370 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
374 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LT);
375 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_NONE);
378 case ASM_OP_CMP_LT_AND:
379 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LT);
380 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
383 case ASM_OP_CMP_LT_OR:
384 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LT);
385 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
388 case ASM_OP_CMP_LT_OR_ANDCM:
389 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LT);
390 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
393 case ASM_OP_CMP_LT_UNC:
394 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LT);
395 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_UNC);
399 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LTU);
400 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_NONE);
403 case ASM_OP_CMP_LTU_UNC:
404 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LTU);
405 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_UNC);
408 case ASM_OP_CMP_NE_AND:
409 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_NE);
410 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
413 case ASM_OP_CMP_NE_OR:
414 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_NE);
415 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
418 case ASM_OP_CMP_NE_OR_ANDCM:
419 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_NE);
420 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
424 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_EQ);
425 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_NONE);
428 case ASM_OP_CMP4_EQ_AND:
429 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_EQ);
430 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
433 case ASM_OP_CMP4_EQ_OR:
434 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_EQ);
435 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
438 case ASM_OP_CMP4_EQ_OR_ANDCM:
439 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_EQ);
440 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
443 case ASM_OP_CMP4_EQ_UNC:
444 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_EQ);
445 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_UNC);
448 case ASM_OP_CMP4_GE_AND:
449 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_GE);
450 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
453 case ASM_OP_CMP4_GE_OR:
454 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_GE);
455 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
458 case ASM_OP_CMP4_GE_OR_ANDCM:
459 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_GE);
460 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
463 case ASM_OP_CMP4_GT_AND:
464 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_GT);
465 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
468 case ASM_OP_CMP4_GT_OR:
469 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_GT);
470 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
473 case ASM_OP_CMP4_GT_OR_ANDCM:
474 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_GT);
475 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
478 case ASM_OP_CMP4_LE_AND:
479 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LE);
480 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
483 case ASM_OP_CMP4_LE_OR:
484 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LE);
485 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
488 case ASM_OP_CMP4_LE_OR_ANDCM:
489 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LE);
490 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
494 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LT);
495 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_NONE);
498 case ASM_OP_CMP4_LT_AND:
499 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LT);
500 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
503 case ASM_OP_CMP4_LT_OR:
504 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LT);
505 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
508 case ASM_OP_CMP4_LT_OR_ANDCM:
509 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LT);
510 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
513 case ASM_OP_CMP4_LT_UNC:
514 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LT);
515 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_UNC);
518 case ASM_OP_CMP4_LTU:
519 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LTU);
520 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_NONE);
523 case ASM_OP_CMP4_LTU_UNC:
524 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_LTU);
525 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_UNC);
528 case ASM_OP_CMP4_NE_AND:
529 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_NE);
530 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
533 case ASM_OP_CMP4_NE_OR:
534 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_NE);
535 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
538 case ASM_OP_CMP4_NE_OR_ANDCM:
539 asm_cmpltr_add(i, ASM_CC_CREL, ASM_CT_NE);
540 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
543 case ASM_OP_CMP8XCHG16_ACQ:
544 asm_cmpltr_add(i, ASM_CC_SEM, ASM_CT_ACQ);
545 op = ASM_OP_CMP8XCHG16;
547 case ASM_OP_CMP8XCHG16_REL:
548 asm_cmpltr_add(i, ASM_CC_SEM, ASM_CT_REL);
549 op = ASM_OP_CMP8XCHG16;
551 case ASM_OP_CMPXCHG1_ACQ:
552 asm_cmpltr_add(i, ASM_CC_SEM, ASM_CT_ACQ);
553 op = ASM_OP_CMPXCHG1;
555 case ASM_OP_CMPXCHG1_REL:
556 asm_cmpltr_add(i, ASM_CC_SEM, ASM_CT_REL);
557 op = ASM_OP_CMPXCHG1;
559 case ASM_OP_CMPXCHG2_ACQ:
560 asm_cmpltr_add(i, ASM_CC_SEM, ASM_CT_ACQ);
561 op = ASM_OP_CMPXCHG2;
563 case ASM_OP_CMPXCHG2_REL:
564 asm_cmpltr_add(i, ASM_CC_SEM, ASM_CT_REL);
565 op = ASM_OP_CMPXCHG2;
567 case ASM_OP_CMPXCHG4_ACQ:
568 asm_cmpltr_add(i, ASM_CC_SEM, ASM_CT_ACQ);
569 op = ASM_OP_CMPXCHG4;
571 case ASM_OP_CMPXCHG4_REL:
572 asm_cmpltr_add(i, ASM_CC_SEM, ASM_CT_REL);
573 op = ASM_OP_CMPXCHG4;
575 case ASM_OP_CMPXCHG8_ACQ:
576 asm_cmpltr_add(i, ASM_CC_SEM, ASM_CT_ACQ);
577 op = ASM_OP_CMPXCHG8;
579 case ASM_OP_CMPXCHG8_REL:
580 asm_cmpltr_add(i, ASM_CC_SEM, ASM_CT_REL);
581 op = ASM_OP_CMPXCHG8;
584 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_L);
588 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_R);
592 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_L);
596 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_R);
600 asm_cmpltr_add(i, ASM_CC_DEP, ASM_CT_NONE);
604 asm_cmpltr_add(i, ASM_CC_DEP, ASM_CT_Z);
608 asm_cmpltr_add(i, ASM_CC_FC, ASM_CT_NONE);
612 asm_cmpltr_add(i, ASM_CC_FC, ASM_CT_I);
615 case ASM_OP_FCLASS_M:
616 asm_cmpltr_add(i, ASM_CC_FCREL, ASM_CT_M);
620 asm_cmpltr_add(i, ASM_CC_FCVT, ASM_CT_FX);
621 asm_cmpltr_add(i, ASM_CC_TRUNC, ASM_CT_NONE);
624 case ASM_OP_FCVT_FX_TRUNC:
625 asm_cmpltr_add(i, ASM_CC_FCVT, ASM_CT_FX);
626 asm_cmpltr_add(i, ASM_CC_TRUNC, ASM_CT_TRUNC);
629 case ASM_OP_FCVT_FXU:
630 asm_cmpltr_add(i, ASM_CC_FCVT, ASM_CT_FXU);
631 asm_cmpltr_add(i, ASM_CC_TRUNC, ASM_CT_NONE);
634 case ASM_OP_FCVT_FXU_TRUNC:
635 asm_cmpltr_add(i, ASM_CC_FCVT, ASM_CT_FXU);
636 asm_cmpltr_add(i, ASM_CC_TRUNC, ASM_CT_TRUNC);
640 asm_cmpltr_add(i, ASM_CC_FCVT, ASM_CT_XF);
641 asm_cmpltr_add(i, ASM_CC_TRUNC, ASM_CT_NONE);
644 case ASM_OP_FETCHADD4_ACQ:
645 asm_cmpltr_add(i, ASM_CC_SEM, ASM_CT_ACQ);
646 op = ASM_OP_FETCHADD4;
648 case ASM_OP_FETCHADD4_REL:
649 asm_cmpltr_add(i, ASM_CC_SEM, ASM_CT_REL);
650 op = ASM_OP_FETCHADD4;
652 case ASM_OP_FETCHADD8_ACQ:
653 asm_cmpltr_add(i, ASM_CC_SEM, ASM_CT_ACQ);
654 op = ASM_OP_FETCHADD8;
656 case ASM_OP_FETCHADD8_REL:
657 asm_cmpltr_add(i, ASM_CC_SEM, ASM_CT_REL);
658 op = ASM_OP_FETCHADD8;
661 asm_cmpltr_add(i, ASM_CC_PC, ASM_CT_NONE);
665 asm_cmpltr_add(i, ASM_CC_PC, ASM_CT_D);
669 asm_cmpltr_add(i, ASM_CC_PC, ASM_CT_S);
672 case ASM_OP_FMERGE_NS:
673 asm_cmpltr_add(i, ASM_CC_FMERGE, ASM_CT_NS);
676 case ASM_OP_FMERGE_S:
677 asm_cmpltr_add(i, ASM_CC_FMERGE, ASM_CT_S);
680 case ASM_OP_FMERGE_SE:
681 asm_cmpltr_add(i, ASM_CC_FMERGE, ASM_CT_SE);
685 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_L);
689 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_LR);
693 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_R);
697 asm_cmpltr_add(i, ASM_CC_PC, ASM_CT_NONE);
701 asm_cmpltr_add(i, ASM_CC_PC, ASM_CT_D);
705 asm_cmpltr_add(i, ASM_CC_PC, ASM_CT_S);
709 asm_cmpltr_add(i, ASM_CC_PC, ASM_CT_NONE);
713 asm_cmpltr_add(i, ASM_CC_PC, ASM_CT_D);
717 asm_cmpltr_add(i, ASM_CC_PC, ASM_CT_S);
720 case ASM_OP_FPCMP_EQ:
721 asm_cmpltr_add(i, ASM_CC_FREL, ASM_CT_EQ);
724 case ASM_OP_FPCMP_LE:
725 asm_cmpltr_add(i, ASM_CC_FREL, ASM_CT_LE);
728 case ASM_OP_FPCMP_LT:
729 asm_cmpltr_add(i, ASM_CC_FREL, ASM_CT_LT);
732 case ASM_OP_FPCMP_NEQ:
733 asm_cmpltr_add(i, ASM_CC_FREL, ASM_CT_NEQ);
736 case ASM_OP_FPCMP_NLE:
737 asm_cmpltr_add(i, ASM_CC_FREL, ASM_CT_NLE);
740 case ASM_OP_FPCMP_NLT:
741 asm_cmpltr_add(i, ASM_CC_FREL, ASM_CT_NLT);
744 case ASM_OP_FPCMP_ORD:
745 asm_cmpltr_add(i, ASM_CC_FREL, ASM_CT_ORD);
748 case ASM_OP_FPCMP_UNORD:
749 asm_cmpltr_add(i, ASM_CC_FREL, ASM_CT_UNORD);
752 case ASM_OP_FPCVT_FX:
753 asm_cmpltr_add(i, ASM_CC_FCVT, ASM_CT_FX);
754 asm_cmpltr_add(i, ASM_CC_TRUNC, ASM_CT_NONE);
757 case ASM_OP_FPCVT_FX_TRUNC:
758 asm_cmpltr_add(i, ASM_CC_FCVT, ASM_CT_FX);
759 asm_cmpltr_add(i, ASM_CC_TRUNC, ASM_CT_TRUNC);
762 case ASM_OP_FPCVT_FXU:
763 asm_cmpltr_add(i, ASM_CC_FCVT, ASM_CT_FXU);
764 asm_cmpltr_add(i, ASM_CC_TRUNC, ASM_CT_NONE);
767 case ASM_OP_FPCVT_FXU_TRUNC:
768 asm_cmpltr_add(i, ASM_CC_FCVT, ASM_CT_FXU);
769 asm_cmpltr_add(i, ASM_CC_TRUNC, ASM_CT_TRUNC);
772 case ASM_OP_FPMERGE_NS:
773 asm_cmpltr_add(i, ASM_CC_FMERGE, ASM_CT_NS);
776 case ASM_OP_FPMERGE_S:
777 asm_cmpltr_add(i, ASM_CC_FMERGE, ASM_CT_S);
780 case ASM_OP_FPMERGE_SE:
781 asm_cmpltr_add(i, ASM_CC_FMERGE, ASM_CT_SE);
785 asm_cmpltr_add(i, ASM_CC_FSWAP, ASM_CT_NONE);
788 case ASM_OP_FSWAP_NL:
789 asm_cmpltr_add(i, ASM_CC_FSWAP, ASM_CT_NL);
792 case ASM_OP_FSWAP_NR:
793 asm_cmpltr_add(i, ASM_CC_FSWAP, ASM_CT_NR);
797 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_L);
801 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_R);
805 asm_cmpltr_add(i, ASM_CC_GETF, ASM_CT_D);
808 case ASM_OP_GETF_EXP:
809 asm_cmpltr_add(i, ASM_CC_GETF, ASM_CT_EXP);
813 asm_cmpltr_add(i, ASM_CC_GETF, ASM_CT_S);
816 case ASM_OP_GETF_SIG:
817 asm_cmpltr_add(i, ASM_CC_GETF, ASM_CT_SIG);
821 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_B);
825 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_F);
829 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_I);
833 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_M);
837 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_X);
841 asm_cmpltr_add(i, ASM_CC_INVALA, ASM_CT_NONE);
844 case ASM_OP_INVALA_E:
845 asm_cmpltr_add(i, ASM_CC_INVALA, ASM_CT_E);
849 asm_cmpltr_add(i, ASM_CC_ITC, ASM_CT_D);
853 asm_cmpltr_add(i, ASM_CC_ITC, ASM_CT_I);
857 asm_cmpltr_add(i, ASM_CC_ITR, ASM_CT_D);
862 asm_cmpltr_add(i, ASM_CC_ITR, ASM_CT_I);
867 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_NONE);
871 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_A);
875 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_ACQ);
878 case ASM_OP_LD1_BIAS:
879 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_BIAS);
882 case ASM_OP_LD1_C_CLR:
883 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_C_CLR);
886 case ASM_OP_LD1_C_CLR_ACQ:
887 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_C_CLR_ACQ);
890 case ASM_OP_LD1_C_NC:
891 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_C_NC);
895 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_S);
899 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_SA);
903 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_NONE);
906 case ASM_OP_LD16_ACQ:
907 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_ACQ);
911 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_NONE);
915 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_A);
919 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_ACQ);
922 case ASM_OP_LD2_BIAS:
923 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_BIAS);
926 case ASM_OP_LD2_C_CLR:
927 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_C_CLR);
930 case ASM_OP_LD2_C_CLR_ACQ:
931 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_C_CLR_ACQ);
934 case ASM_OP_LD2_C_NC:
935 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_C_NC);
939 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_S);
943 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_SA);
947 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_NONE);
951 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_A);
955 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_ACQ);
958 case ASM_OP_LD4_BIAS:
959 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_BIAS);
962 case ASM_OP_LD4_C_CLR:
963 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_C_CLR);
966 case ASM_OP_LD4_C_CLR_ACQ:
967 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_C_CLR_ACQ);
970 case ASM_OP_LD4_C_NC:
971 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_C_NC);
975 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_S);
979 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_SA);
983 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_NONE);
987 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_A);
991 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_ACQ);
994 case ASM_OP_LD8_BIAS:
995 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_BIAS);
998 case ASM_OP_LD8_C_CLR:
999 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_C_CLR);
1002 case ASM_OP_LD8_C_CLR_ACQ:
1003 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_C_CLR_ACQ);
1006 case ASM_OP_LD8_C_NC:
1007 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_C_NC);
1010 case ASM_OP_LD8_FILL:
1011 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_FILL);
1015 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_S);
1019 asm_cmpltr_add(i, ASM_CC_LDTYPE, ASM_CT_SA);
1022 case ASM_OP_LDF_FILL:
1023 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_FILL);
1027 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_NONE);
1031 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_A);
1034 case ASM_OP_LDF8_C_CLR:
1035 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_C_CLR);
1038 case ASM_OP_LDF8_C_NC:
1039 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_C_NC);
1043 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_S);
1046 case ASM_OP_LDF8_SA:
1047 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_SA);
1051 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_NONE);
1055 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_A);
1058 case ASM_OP_LDFD_C_CLR:
1059 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_C_CLR);
1062 case ASM_OP_LDFD_C_NC:
1063 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_C_NC);
1067 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_S);
1070 case ASM_OP_LDFD_SA:
1071 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_SA);
1075 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_NONE);
1079 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_A);
1082 case ASM_OP_LDFE_C_CLR:
1083 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_C_CLR);
1086 case ASM_OP_LDFE_C_NC:
1087 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_C_NC);
1091 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_S);
1094 case ASM_OP_LDFE_SA:
1095 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_SA);
1099 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_NONE);
1102 case ASM_OP_LDFP8_A:
1103 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_A);
1106 case ASM_OP_LDFP8_C_CLR:
1107 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_C_CLR);
1110 case ASM_OP_LDFP8_C_NC:
1111 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_C_NC);
1114 case ASM_OP_LDFP8_S:
1115 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_S);
1118 case ASM_OP_LDFP8_SA:
1119 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_SA);
1123 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_NONE);
1126 case ASM_OP_LDFPD_A:
1127 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_A);
1130 case ASM_OP_LDFPD_C_CLR:
1131 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_C_CLR);
1134 case ASM_OP_LDFPD_C_NC:
1135 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_C_NC);
1138 case ASM_OP_LDFPD_S:
1139 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_S);
1142 case ASM_OP_LDFPD_SA:
1143 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_SA);
1147 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_NONE);
1150 case ASM_OP_LDFPS_A:
1151 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_A);
1154 case ASM_OP_LDFPS_C_CLR:
1155 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_C_CLR);
1158 case ASM_OP_LDFPS_C_NC:
1159 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_C_NC);
1162 case ASM_OP_LDFPS_S:
1163 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_S);
1166 case ASM_OP_LDFPS_SA:
1167 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_SA);
1171 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_NONE);
1175 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_A);
1178 case ASM_OP_LDFS_C_CLR:
1179 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_C_CLR);
1182 case ASM_OP_LDFS_C_NC:
1183 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_C_NC);
1187 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_S);
1190 case ASM_OP_LDFS_SA:
1191 asm_cmpltr_add(i, ASM_CC_FLDTYPE, ASM_CT_SA);
1194 case ASM_OP_LFETCH_:
1195 asm_cmpltr_add(i, ASM_CC_LFTYPE, ASM_CT_NONE);
1196 asm_cmpltr_add(i, ASM_CC_LFETCH, ASM_CT_NONE);
1199 case ASM_OP_LFETCH_EXCL:
1200 asm_cmpltr_add(i, ASM_CC_LFTYPE, ASM_CT_NONE);
1201 asm_cmpltr_add(i, ASM_CC_LFETCH, ASM_CT_EXCL);
1204 case ASM_OP_LFETCH_FAULT:
1205 asm_cmpltr_add(i, ASM_CC_LFTYPE, ASM_CT_FAULT);
1206 asm_cmpltr_add(i, ASM_CC_LFETCH, ASM_CT_NONE);
1209 case ASM_OP_LFETCH_FAULT_EXCL:
1210 asm_cmpltr_add(i, ASM_CC_LFTYPE, ASM_CT_FAULT);
1211 asm_cmpltr_add(i, ASM_CC_LFETCH, ASM_CT_EXCL);
1215 asm_cmpltr_add(i, ASM_CC_MF, ASM_CT_NONE);
1219 asm_cmpltr_add(i, ASM_CC_MF, ASM_CT_A);
1223 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_L);
1227 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_R);
1231 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_L);
1235 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_R);
1239 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_L);
1243 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_R);
1247 asm_cmpltr_add(i, ASM_CC_MOV, ASM_CT_NONE);
1251 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_I);
1255 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_M);
1258 case ASM_OP_MOV_RET:
1259 asm_cmpltr_add(i, ASM_CC_MOV, ASM_CT_RET);
1262 case ASM_OP_MOV_CPUID:
1263 ot = ASM_OPER_CPUID;
1266 case ASM_OP_MOV_DBR:
1270 case ASM_OP_MOV_IBR:
1278 case ASM_OP_MOV_MSR:
1282 case ASM_OP_MOV_PKR:
1286 case ASM_OP_MOV_PMC:
1290 case ASM_OP_MOV_PMD:
1298 case ASM_OP_MOV_PSR:
1302 case ASM_OP_MOV_PSR_L:
1303 ot = ASM_OPER_PSR_L;
1306 case ASM_OP_MOV_PSR_UM:
1307 ot = ASM_OPER_PSR_UM;
1315 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_B);
1319 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_F);
1323 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_I);
1327 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_M);
1331 asm_cmpltr_add(i, ASM_CC_UNIT, ASM_CT_X);
1334 case ASM_OP_PACK2_SSS:
1335 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_SSS);
1338 case ASM_OP_PACK2_USS:
1339 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_USS);
1342 case ASM_OP_PACK4_SSS:
1343 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_SSS);
1347 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_NONE);
1350 case ASM_OP_PADD1_SSS:
1351 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_SSS);
1354 case ASM_OP_PADD1_UUS:
1355 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_UUS);
1358 case ASM_OP_PADD1_UUU:
1359 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_UUU);
1363 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_NONE);
1366 case ASM_OP_PADD2_SSS:
1367 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_SSS);
1370 case ASM_OP_PADD2_UUS:
1371 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_UUS);
1374 case ASM_OP_PADD2_UUU:
1375 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_UUU);
1379 asm_cmpltr_add(i, ASM_CC_PAVG, ASM_CT_NONE);
1382 case ASM_OP_PAVG1_RAZ:
1383 asm_cmpltr_add(i, ASM_CC_PAVG, ASM_CT_RAZ);
1387 asm_cmpltr_add(i, ASM_CC_PAVG, ASM_CT_NONE);
1390 case ASM_OP_PAVG2_RAZ:
1391 asm_cmpltr_add(i, ASM_CC_PAVG, ASM_CT_RAZ);
1394 case ASM_OP_PCMP1_EQ:
1395 asm_cmpltr_add(i, ASM_CC_PREL, ASM_CT_EQ);
1398 case ASM_OP_PCMP1_GT:
1399 asm_cmpltr_add(i, ASM_CC_PREL, ASM_CT_GT);
1402 case ASM_OP_PCMP2_EQ:
1403 asm_cmpltr_add(i, ASM_CC_PREL, ASM_CT_EQ);
1406 case ASM_OP_PCMP2_GT:
1407 asm_cmpltr_add(i, ASM_CC_PREL, ASM_CT_GT);
1410 case ASM_OP_PCMP4_EQ:
1411 asm_cmpltr_add(i, ASM_CC_PREL, ASM_CT_EQ);
1414 case ASM_OP_PCMP4_GT:
1415 asm_cmpltr_add(i, ASM_CC_PREL, ASM_CT_GT);
1418 case ASM_OP_PMAX1_U:
1419 asm_cmpltr_add(i, ASM_CC_UNS, ASM_CT_U);
1422 case ASM_OP_PMIN1_U:
1423 asm_cmpltr_add(i, ASM_CC_UNS, ASM_CT_U);
1426 case ASM_OP_PMPY2_L:
1427 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_L);
1430 case ASM_OP_PMPY2_R:
1431 asm_cmpltr_add(i, ASM_CC_LR, ASM_CT_R);
1434 case ASM_OP_PMPYSHR2_:
1435 asm_cmpltr_add(i, ASM_CC_UNS, ASM_CT_NONE);
1436 op = ASM_OP_PMPYSHR2;
1438 case ASM_OP_PMPYSHR2_U:
1439 asm_cmpltr_add(i, ASM_CC_UNS, ASM_CT_U);
1440 op = ASM_OP_PMPYSHR2;
1442 case ASM_OP_PROBE_R:
1443 asm_cmpltr_add(i, ASM_CC_RW, ASM_CT_R);
1444 asm_cmpltr_add(i, ASM_CC_PRTYPE, ASM_CT_NONE);
1447 case ASM_OP_PROBE_R_FAULT:
1448 asm_cmpltr_add(i, ASM_CC_RW, ASM_CT_R);
1449 asm_cmpltr_add(i, ASM_CC_PRTYPE, ASM_CT_FAULT);
1452 case ASM_OP_PROBE_RW_FAULT:
1453 asm_cmpltr_add(i, ASM_CC_RW, ASM_CT_RW);
1454 asm_cmpltr_add(i, ASM_CC_PRTYPE, ASM_CT_FAULT);
1457 case ASM_OP_PROBE_W:
1458 asm_cmpltr_add(i, ASM_CC_RW, ASM_CT_W);
1459 asm_cmpltr_add(i, ASM_CC_PRTYPE, ASM_CT_NONE);
1462 case ASM_OP_PROBE_W_FAULT:
1463 asm_cmpltr_add(i, ASM_CC_RW, ASM_CT_W);
1464 asm_cmpltr_add(i, ASM_CC_PRTYPE, ASM_CT_FAULT);
1468 asm_cmpltr_add(i, ASM_CC_UNS, ASM_CT_NONE);
1471 case ASM_OP_PSHR2_U:
1472 asm_cmpltr_add(i, ASM_CC_UNS, ASM_CT_U);
1476 asm_cmpltr_add(i, ASM_CC_UNS, ASM_CT_NONE);
1479 case ASM_OP_PSHR4_U:
1480 asm_cmpltr_add(i, ASM_CC_UNS, ASM_CT_U);
1484 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_NONE);
1487 case ASM_OP_PSUB1_SSS:
1488 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_SSS);
1491 case ASM_OP_PSUB1_UUS:
1492 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_UUS);
1495 case ASM_OP_PSUB1_UUU:
1496 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_UUU);
1500 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_NONE);
1503 case ASM_OP_PSUB2_SSS:
1504 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_SSS);
1507 case ASM_OP_PSUB2_UUS:
1508 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_UUS);
1511 case ASM_OP_PSUB2_UUU:
1512 asm_cmpltr_add(i, ASM_CC_SAT, ASM_CT_UUU);
1516 asm_cmpltr_add(i, ASM_CC_PTC, ASM_CT_E);
1520 asm_cmpltr_add(i, ASM_CC_PTC, ASM_CT_G);
1524 asm_cmpltr_add(i, ASM_CC_PTC, ASM_CT_GA);
1528 asm_cmpltr_add(i, ASM_CC_PTC, ASM_CT_L);
1532 asm_cmpltr_add(i, ASM_CC_PTR, ASM_CT_D);
1536 asm_cmpltr_add(i, ASM_CC_PTR, ASM_CT_I);
1540 asm_cmpltr_add(i, ASM_CC_SETF, ASM_CT_D);
1543 case ASM_OP_SETF_EXP:
1544 asm_cmpltr_add(i, ASM_CC_SETF, ASM_CT_EXP);
1548 asm_cmpltr_add(i, ASM_CC_SETF, ASM_CT_S);
1551 case ASM_OP_SETF_SIG:
1552 asm_cmpltr_add(i, ASM_CC_SETF, ASM_CT_SIG);
1556 asm_cmpltr_add(i, ASM_CC_UNS, ASM_CT_NONE);
1560 asm_cmpltr_add(i, ASM_CC_UNS, ASM_CT_U);
1564 asm_cmpltr_add(i, ASM_CC_SRLZ, ASM_CT_D);
1568 asm_cmpltr_add(i, ASM_CC_SRLZ, ASM_CT_I);
1572 asm_cmpltr_add(i, ASM_CC_STTYPE, ASM_CT_NONE);
1575 case ASM_OP_ST1_REL:
1576 asm_cmpltr_add(i, ASM_CC_STTYPE, ASM_CT_REL);
1580 asm_cmpltr_add(i, ASM_CC_STTYPE, ASM_CT_NONE);
1583 case ASM_OP_ST16_REL:
1584 asm_cmpltr_add(i, ASM_CC_STTYPE, ASM_CT_REL);
1588 asm_cmpltr_add(i, ASM_CC_STTYPE, ASM_CT_NONE);
1591 case ASM_OP_ST2_REL:
1592 asm_cmpltr_add(i, ASM_CC_STTYPE, ASM_CT_REL);
1596 asm_cmpltr_add(i, ASM_CC_STTYPE, ASM_CT_NONE);
1599 case ASM_OP_ST4_REL:
1600 asm_cmpltr_add(i, ASM_CC_STTYPE, ASM_CT_REL);
1604 asm_cmpltr_add(i, ASM_CC_STTYPE, ASM_CT_NONE);
1607 case ASM_OP_ST8_REL:
1608 asm_cmpltr_add(i, ASM_CC_STTYPE, ASM_CT_REL);
1611 case ASM_OP_ST8_SPILL:
1612 asm_cmpltr_add(i, ASM_CC_STTYPE, ASM_CT_SPILL);
1615 case ASM_OP_STF_SPILL:
1616 asm_cmpltr_add(i, ASM_CC_STTYPE, ASM_CT_SPILL);
1620 asm_cmpltr_add(i, ASM_CC_SYNC, ASM_CT_I);
1623 case ASM_OP_TBIT_NZ_AND:
1624 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_NZ);
1625 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
1628 case ASM_OP_TBIT_NZ_OR:
1629 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_NZ);
1630 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
1633 case ASM_OP_TBIT_NZ_OR_ANDCM:
1634 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_NZ);
1635 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
1639 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_Z);
1640 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_NONE);
1643 case ASM_OP_TBIT_Z_AND:
1644 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_Z);
1645 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
1648 case ASM_OP_TBIT_Z_OR:
1649 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_Z);
1650 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
1653 case ASM_OP_TBIT_Z_OR_ANDCM:
1654 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_Z);
1655 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
1658 case ASM_OP_TBIT_Z_UNC:
1659 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_Z);
1660 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_UNC);
1663 case ASM_OP_TF_NZ_AND:
1664 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_NZ);
1665 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
1668 case ASM_OP_TF_NZ_OR:
1669 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_NZ);
1670 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
1673 case ASM_OP_TF_NZ_OR_ANDCM:
1674 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_NZ);
1675 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
1679 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_Z);
1680 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_NONE);
1683 case ASM_OP_TF_Z_AND:
1684 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_Z);
1685 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
1688 case ASM_OP_TF_Z_OR:
1689 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_Z);
1690 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
1693 case ASM_OP_TF_Z_OR_ANDCM:
1694 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_Z);
1695 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
1698 case ASM_OP_TF_Z_UNC:
1699 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_Z);
1700 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_UNC);
1703 case ASM_OP_TNAT_NZ_AND:
1704 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_NZ);
1705 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
1708 case ASM_OP_TNAT_NZ_OR:
1709 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_NZ);
1710 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
1713 case ASM_OP_TNAT_NZ_OR_ANDCM:
1714 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_NZ);
1715 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
1719 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_Z);
1720 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_NONE);
1723 case ASM_OP_TNAT_Z_AND:
1724 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_Z);
1725 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_AND);
1728 case ASM_OP_TNAT_Z_OR:
1729 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_Z);
1730 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR);
1733 case ASM_OP_TNAT_Z_OR_ANDCM:
1734 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_Z);
1735 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_OR_ANDCM);
1738 case ASM_OP_TNAT_Z_UNC:
1739 asm_cmpltr_add(i, ASM_CC_TREL, ASM_CT_Z);
1740 asm_cmpltr_add(i, ASM_CC_CTYPE, ASM_CT_UNC);
1743 case ASM_OP_UNPACK1_H:
1744 asm_cmpltr_add(i, ASM_CC_UNPACK, ASM_CT_H);
1745 op = ASM_OP_UNPACK1;
1747 case ASM_OP_UNPACK1_L:
1748 asm_cmpltr_add(i, ASM_CC_UNPACK, ASM_CT_L);
1749 op = ASM_OP_UNPACK1;
1751 case ASM_OP_UNPACK2_H:
1752 asm_cmpltr_add(i, ASM_CC_UNPACK, ASM_CT_H);
1753 op = ASM_OP_UNPACK2;
1755 case ASM_OP_UNPACK2_L:
1756 asm_cmpltr_add(i, ASM_CC_UNPACK, ASM_CT_L);
1757 op = ASM_OP_UNPACK2;
1759 case ASM_OP_UNPACK4_H:
1760 asm_cmpltr_add(i, ASM_CC_UNPACK, ASM_CT_H);
1761 op = ASM_OP_UNPACK4;
1763 case ASM_OP_UNPACK4_L:
1764 asm_cmpltr_add(i, ASM_CC_UNPACK, ASM_CT_L);
1765 op = ASM_OP_UNPACK4;
1768 asm_cmpltr_add(i, ASM_CC_VMSW, ASM_CT_0);
1772 asm_cmpltr_add(i, ASM_CC_VMSW, ASM_CT_1);
1776 asm_cmpltr_add(i, ASM_CC_XMA, ASM_CT_H);
1780 asm_cmpltr_add(i, ASM_CC_XMA, ASM_CT_HU);
1784 asm_cmpltr_add(i, ASM_CC_XMA, ASM_CT_L);
1788 KASSERT(op < ASM_OP_NUMBER_OF_OPCODES, ("foo"));
1795 static __inline void
1796 op_imm(struct asm_inst *i, int op, uint64_t val)
1798 i->i_oper[op].o_type = ASM_OPER_IMM;
1799 i->i_oper[op].o_value = val;
1802 static __inline void
1803 op_type(struct asm_inst *i, int op, enum asm_oper_type ot)
1805 i->i_oper[op].o_type = ot;
1808 static __inline void
1809 op_value(struct asm_inst *i, int op, uint64_t val)
1811 i->i_oper[op].o_value = val;
1814 static __inline void
1815 operand(struct asm_inst *i, int op, enum asm_oper_type ot, uint64_t bits,
1818 i->i_oper[op].o_type = ot;
1819 i->i_oper[op].o_value = FIELD(bits, o, l);
1823 imm(uint64_t bits, int sign, int o, int l)
1825 uint64_t val = FIELD(bits, o, l);
1827 if (sign && (val & (1LL << (l - 1))) != 0)
1833 s_imm(struct asm_inst *i, int op, uint64_t bits, int o, int l)
1835 i->i_oper[op].o_type = ASM_OPER_IMM;
1836 i->i_oper[op].o_value = imm(bits, 1, o, l);
1840 u_imm(struct asm_inst *i, int op, uint64_t bits, int o, int l)
1842 i->i_oper[op].o_type = ASM_OPER_IMM;
1843 i->i_oper[op].o_value = imm(bits, 0, o, l);
1847 vimm(uint64_t bits, int sign, va_list ap)
1853 while ((frag = va_arg(ap, int)) != 0) {
1854 val |= (uint64_t)FIELD(bits, FRAG_OFS(frag), FRAG_LEN(frag))
1856 len += FRAG_LEN(frag);
1858 if (sign && (val & (1LL << (len - 1))) != 0)
1864 s_immf(struct asm_inst *i, int op, uint64_t bits, ...)
1868 i->i_oper[op].o_type = ASM_OPER_IMM;
1869 i->i_oper[op].o_value = vimm(bits, 1, ap);
1874 u_immf(struct asm_inst *i, int op, uint64_t bits, ...)
1878 i->i_oper[op].o_type = ASM_OPER_IMM;
1879 i->i_oper[op].o_value = vimm(bits, 0, ap);
1884 disp(struct asm_inst *i, int op, uint64_t bits, ...)
1888 i->i_oper[op].o_type = ASM_OPER_DISP;
1889 i->i_oper[op].o_value = vimm(bits, 1, ap) << 4;
1893 static __inline void
1894 combine(uint64_t *dst, int dl, uint64_t src, int sl, int so)
1896 *dst = (*dst & ((1LL << dl) - 1LL)) |
1897 ((uint64_t)_FLD64(src, so, sl) << dl);
1901 asm_extract(enum asm_op op, enum asm_fmt fmt, uint64_t bits,
1902 struct asm_bundle *b, int slot)
1904 struct asm_inst *i = b->b_inst + slot;
1905 enum asm_oper_type ot;
1907 KASSERT(op != ASM_OP_NONE, ("foo"));
1912 ot = asm_normalize(i, op);
1914 if (fmt != ASM_FMT_B6 && fmt != ASM_FMT_B7)
1915 operand(i, 0, ASM_OPER_PREG, bits, 0, 6);
1919 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
1920 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
1921 operand(i, 3, ASM_OPER_GREG, bits, 20, 7);
1922 if ((op == ASM_OP_ADD && FIELD(bits, 27, 2) == 1) ||
1923 (op == ASM_OP_SUB && FIELD(bits, 27, 2) == 0))
1927 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
1928 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
1929 op_imm(i, 3, 1LL + FIELD(bits, 27, 2));
1930 operand(i, 4, ASM_OPER_GREG, bits, 20, 7);
1933 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
1934 s_immf(i, 2, bits, FRAG(13,7), FRAG(36,1), 0);
1935 operand(i, 3, ASM_OPER_GREG, bits, 20, 7);
1938 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
1939 s_immf(i, 2, bits, FRAG(13,7), FRAG(27,6), FRAG(36,1), 0);
1940 operand(i, 3, ASM_OPER_GREG, bits, 20, 7);
1943 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
1944 s_immf(i, 2, bits, FRAG(13,7), FRAG(27,9), FRAG(22,5),
1946 operand(i, 3, ASM_OPER_GREG, bits, 20, 2);
1948 case ASM_FMT_A6: /* 2 dst */
1949 operand(i, 1, ASM_OPER_PREG, bits, 6, 6);
1950 operand(i, 2, ASM_OPER_PREG, bits, 27, 6);
1951 operand(i, 3, ASM_OPER_GREG, bits, 13, 7);
1952 operand(i, 4, ASM_OPER_GREG, bits, 20, 7);
1955 case ASM_FMT_A7: /* 2 dst */
1956 if (FIELD(bits, 13, 7) != 0)
1958 operand(i, 1, ASM_OPER_PREG, bits, 6, 6);
1959 operand(i, 2, ASM_OPER_PREG, bits, 27, 6);
1960 operand(i, 3, ASM_OPER_GREG, bits, 13, 7);
1961 operand(i, 4, ASM_OPER_GREG, bits, 20, 7);
1964 case ASM_FMT_A8: /* 2 dst */
1965 operand(i, 1, ASM_OPER_PREG, bits, 6, 6);
1966 operand(i, 2, ASM_OPER_PREG, bits, 27, 6);
1967 s_immf(i, 3, bits, FRAG(13,7), FRAG(36,1), 0);
1968 operand(i, 4, ASM_OPER_GREG, bits, 20, 7);
1972 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
1973 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
1974 operand(i, 3, ASM_OPER_GREG, bits, 20, 7);
1977 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
1978 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
1979 op_imm(i, 3, 1LL + FIELD(bits, 27, 2));
1980 operand(i, 4, ASM_OPER_GREG, bits, 20, 7);
1982 case ASM_FMT_B1: /* 0 dst */
1984 disp(i, 1, bits, FRAG(13,20), FRAG(36,1), 0);
1986 case ASM_FMT_B2: /* 0 dst */
1987 if (FIELD(bits, 0, 6) != 0)
1990 disp(i, 1, bits, FRAG(13,20), FRAG(36,1), 0);
1994 operand(i, 1, ASM_OPER_BREG, bits, 6, 3);
1995 disp(i, 2, bits, FRAG(13,20), FRAG(36,1), 0);
1997 case ASM_FMT_B4: /* 0 dst */
1999 operand(i, 1, ASM_OPER_BREG, bits, 13, 3);
2003 if (FIELD(bits, 32, 1) == 0)
2007 operand(i, 1, ASM_OPER_BREG, bits, 6, 3);
2008 operand(i, 2, ASM_OPER_BREG, bits, 13, 3);
2010 case ASM_FMT_B6: /* 0 dst */
2012 disp(i, 1, bits, FRAG(13,20), FRAG(36,1), 0);
2013 disp(i, 2, bits, FRAG(6,7), FRAG(33,2), 0);
2016 case ASM_FMT_B7: /* 0 dst */
2018 operand(i, 1, ASM_OPER_BREG, bits, 13, 3);
2019 disp(i, 2, bits, FRAG(6,7), FRAG(33,2), 0);
2025 case ASM_FMT_B9: /* 0 dst */
2026 u_immf(i, 1, bits, FRAG(6,20), FRAG(36,1), 0);
2030 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2031 operand(i, 2, ASM_OPER_FREG, bits, 13, 7);
2032 operand(i, 3, ASM_OPER_FREG, bits, 20, 7);
2033 operand(i, 4, ASM_OPER_FREG, bits, 27, 7);
2036 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2037 operand(i, 2, ASM_OPER_FREG, bits, 13, 7);
2038 operand(i, 3, ASM_OPER_FREG, bits, 20, 7);
2039 operand(i, 4, ASM_OPER_FREG, bits, 27, 7);
2042 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2043 operand(i, 2, ASM_OPER_FREG, bits, 13, 7);
2044 operand(i, 3, ASM_OPER_FREG, bits, 20, 7);
2045 operand(i, 4, ASM_OPER_FREG, bits, 27, 7);
2047 case ASM_FMT_F4: /* 2 dst */
2048 if (FIELD(bits, 33, 1)) { /* ra */
2049 if (FIELD(bits, 36, 1)) /* rb */
2050 asm_cmpltr_add(i, ASM_CC_FREL, ASM_CT_UNORD);
2052 asm_cmpltr_add(i, ASM_CC_FREL, ASM_CT_LE);
2054 if (FIELD(bits, 36, 1)) /* rb */
2055 asm_cmpltr_add(i, ASM_CC_FREL, ASM_CT_LT);
2057 asm_cmpltr_add(i, ASM_CC_FREL, ASM_CT_EQ);
2059 if (FIELD(bits, 12, 1)) /* ta */
2060 asm_cmpltr_add(i, ASM_CC_FCTYPE, ASM_CT_UNC);
2062 asm_cmpltr_add(i, ASM_CC_FCTYPE, ASM_CT_NONE);
2064 operand(i, 1, ASM_OPER_PREG, bits, 6, 6);
2065 operand(i, 2, ASM_OPER_PREG, bits, 27, 6);
2066 operand(i, 3, ASM_OPER_FREG, bits, 13, 7);
2067 operand(i, 4, ASM_OPER_FREG, bits, 20, 7);
2070 case ASM_FMT_F5: /* 2 dst */
2071 operand(i, 1, ASM_OPER_PREG, bits, 6, 6);
2072 operand(i, 2, ASM_OPER_PREG, bits, 27, 6);
2073 operand(i, 3, ASM_OPER_FREG, bits, 13, 7);
2074 u_immf(i, 4, bits, FRAG(33,2), FRAG(20,7), 0);
2077 case ASM_FMT_F6: /* 2 dst */
2079 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2080 operand(i, 2, ASM_OPER_PREG, bits, 27, 6);
2081 operand(i, 3, ASM_OPER_FREG, bits, 13, 7);
2082 operand(i, 4, ASM_OPER_FREG, bits, 20, 7);
2085 case ASM_FMT_F7: /* 2 dst */
2087 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2088 operand(i, 2, ASM_OPER_PREG, bits, 27, 6);
2089 operand(i, 3, ASM_OPER_FREG, bits, 20, 7);
2094 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2095 operand(i, 2, ASM_OPER_FREG, bits, 13, 7);
2096 operand(i, 3, ASM_OPER_FREG, bits, 20, 7);
2099 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2100 operand(i, 2, ASM_OPER_FREG, bits, 13, 7);
2101 operand(i, 3, ASM_OPER_FREG, bits, 20, 7);
2105 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2106 operand(i, 2, ASM_OPER_FREG, bits, 13, 7);
2109 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2110 operand(i, 2, ASM_OPER_FREG, bits, 13, 7);
2112 case ASM_FMT_F12: /* 0 dst */
2114 u_imm(i, 1, bits, 13, 7);
2115 u_imm(i, 2, bits, 20, 7);
2122 case ASM_FMT_F14: /* 0 dst */
2124 disp(i, 1, bits, FRAG(6,20), FRAG(36,1), 0);
2126 case ASM_FMT_F15: /* 0 dst */
2127 u_imm(i, 1, bits, 6, 20);
2129 case ASM_FMT_F16: /* 0 dst */
2130 u_imm(i, 1, bits, 6, 20);
2133 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2134 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2135 operand(i, 3, ASM_OPER_GREG, bits, 20, 7);
2136 switch (FIELD(bits, 30, 2)) {
2137 case 0: op_imm(i, 4, 0LL); break;
2138 case 1: op_imm(i, 4, 7LL); break;
2139 case 2: op_imm(i, 4, 15LL); break;
2140 case 3: op_imm(i, 4, 16LL); break;
2144 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2145 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2146 operand(i, 3, ASM_OPER_GREG, bits, 20, 7);
2149 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2150 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2151 u_imm(i, 3, bits, 20, 4);
2154 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2155 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2156 u_imm(i, 3, bits, 20, 8);
2159 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2160 operand(i, 2, ASM_OPER_GREG, bits, 20, 7);
2161 operand(i, 3, ASM_OPER_GREG, bits, 13, 7);
2164 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2165 operand(i, 2, ASM_OPER_GREG, bits, 20, 7);
2166 u_imm(i, 3, bits, 14, 5);
2169 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2170 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2171 operand(i, 3, ASM_OPER_GREG, bits, 20, 7);
2174 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2175 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2176 op_imm(i, 3, 31LL - FIELD(bits, 20, 5));
2179 if (FIELD(bits, 13, 7) != 0)
2181 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2182 operand(i, 2, ASM_OPER_GREG, bits, 20, 7);
2185 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2186 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2187 operand(i, 3, ASM_OPER_GREG, bits, 20, 7);
2188 u_imm(i, 4, bits, 27, 6);
2191 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2192 operand(i, 2, ASM_OPER_GREG, bits, 20, 7);
2193 u_imm(i, 3, bits, 14, 6);
2194 op_imm(i, 4, 1LL + FIELD(bits, 27, 6));
2197 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2198 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2199 op_imm(i, 3, 63LL - FIELD(bits, 20, 6));
2200 op_imm(i, 4, 1LL + FIELD(bits, 27, 6));
2203 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2204 s_immf(i, 2, bits, FRAG(13,7), FRAG(36,1), 0);
2205 op_imm(i, 3, 63LL - FIELD(bits, 20, 6));
2206 op_imm(i, 4, 1LL + FIELD(bits, 27, 6));
2209 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2210 s_imm(i, 2, bits, 36, 1);
2211 operand(i, 3, ASM_OPER_GREG, bits, 20, 7);
2212 op_imm(i, 4, 63LL - FIELD(bits, 14, 6));
2213 op_imm(i, 5, 1LL + FIELD(bits, 27, 6));
2216 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2217 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2218 operand(i, 3, ASM_OPER_GREG, bits, 20, 7);
2219 op_imm(i, 4, 63LL - FIELD(bits, 31, 6));
2220 op_imm(i, 5, 1LL + FIELD(bits, 27, 4));
2222 case ASM_FMT_I16: /* 2 dst */
2223 operand(i, 1, ASM_OPER_PREG, bits, 6, 6);
2224 operand(i, 2, ASM_OPER_PREG, bits, 27, 6);
2225 operand(i, 3, ASM_OPER_GREG, bits, 20, 7);
2226 u_imm(i, 4, bits, 14, 6);
2229 case ASM_FMT_I17: /* 2 dst */
2230 operand(i, 1, ASM_OPER_PREG, bits, 6, 6);
2231 operand(i, 2, ASM_OPER_PREG, bits, 27, 6);
2232 operand(i, 3, ASM_OPER_GREG, bits, 20, 7);
2236 u_immf(i, 1, bits, FRAG(6,20), FRAG(36,1), 0);
2239 u_immf(i, 1, bits, FRAG(6,20), FRAG(36,1), 0);
2241 case ASM_FMT_I20: /* 0 dst */
2242 operand(i, 1, ASM_OPER_GREG, bits, 13, 7);
2243 disp(i, 2, bits, FRAG(6,7), FRAG(20,13), FRAG(36,1), 0);
2247 switch (FIELD(bits, 20, 2)) { /* wh */
2248 case 0: asm_cmpltr_add(i, ASM_CC_MWH, ASM_CT_SPTK); break;
2249 case 1: asm_cmpltr_add(i, ASM_CC_MWH, ASM_CT_NONE); break;
2250 case 2: asm_cmpltr_add(i, ASM_CC_MWH, ASM_CT_DPTK); break;
2253 if (FIELD(bits, 23, 1)) /* ih */
2254 asm_cmpltr_add(i, ASM_CC_IH, ASM_CT_IMP);
2256 asm_cmpltr_add(i, ASM_CC_IH, ASM_CT_NONE);
2257 operand(i, 1, ASM_OPER_BREG, bits, 6, 3);
2258 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2259 disp(i, 3, bits, FRAG(24,9), 0);
2262 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2263 operand(i, 2, ASM_OPER_BREG, bits, 13, 3);
2266 op_type(i, 1, ASM_OPER_PR);
2267 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2268 u_immf(i, 3, bits, FRAG(6,7), FRAG(24,8), FRAG(36,1), 0);
2269 i->i_oper[3].o_value <<= 1;
2272 op_type(i, 1, ASM_OPER_PR_ROT);
2273 s_immf(i, 2, bits, FRAG(6,27), FRAG(36,1), 0);
2276 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2280 operand(i, 1, ASM_OPER_AREG, bits, 20, 7);
2281 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2284 operand(i, 1, ASM_OPER_AREG, bits, 20, 7);
2285 s_immf(i, 2, bits, FRAG(13,7), FRAG(36,1), 0);
2288 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2289 operand(i, 2, ASM_OPER_AREG, bits, 20, 7);
2292 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2293 operand(i, 2, ASM_OPER_GREG, bits, 20, 7);
2295 case ASM_FMT_I30: /* 2 dst */
2296 operand(i, 1, ASM_OPER_PREG, bits, 6, 6);
2297 operand(i, 2, ASM_OPER_PREG, bits, 27, 6);
2298 op_imm(i, 3, 32LL + FIELD(bits, 14, 5));
2302 asm_hint(i, ASM_CC_LDHINT);
2303 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2304 if (i->i_op == ASM_OP_LD16) {
2305 op_type(i, 2, ASM_OPER_AREG);
2306 op_value(i, 2, AR_CSD);
2309 operand(i, i->i_srcidx, ASM_OPER_MEM, bits, 20, 7);
2312 asm_hint(i, ASM_CC_LDHINT);
2313 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2314 operand(i, 2, ASM_OPER_MEM, bits, 20, 7);
2315 operand(i, 3, ASM_OPER_GREG, bits, 13, 7);
2318 asm_hint(i, ASM_CC_LDHINT);
2319 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2320 operand(i, 2, ASM_OPER_MEM, bits, 20, 7);
2321 s_immf(i, 3, bits, FRAG(13,7), FRAG(27,1), FRAG(36,1), 0);
2324 asm_hint(i, ASM_CC_STHINT);
2325 operand(i, 1, ASM_OPER_MEM, bits, 20, 7);
2326 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2327 if (i->i_op == ASM_OP_ST16) {
2328 op_type(i, 3, ASM_OPER_AREG);
2329 op_value(i, 3, AR_CSD);
2333 asm_hint(i, ASM_CC_STHINT);
2334 operand(i, 1, ASM_OPER_MEM, bits, 20, 7);
2335 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2336 s_immf(i, 3, bits, FRAG(6,7), FRAG(27,1), FRAG(36,1), 0);
2339 asm_hint(i, ASM_CC_LDHINT);
2340 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2341 operand(i, 2, ASM_OPER_MEM, bits, 20, 7);
2344 asm_hint(i, ASM_CC_LDHINT);
2345 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2346 operand(i, 2, ASM_OPER_MEM, bits, 20, 7);
2347 operand(i, 3, ASM_OPER_GREG, bits, 13, 7);
2350 asm_hint(i, ASM_CC_LDHINT);
2351 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2352 operand(i, 2, ASM_OPER_MEM, bits, 20, 7);
2353 s_immf(i, 3, bits, FRAG(13,7), FRAG(27,1), FRAG(36,1), 0);
2356 asm_hint(i, ASM_CC_STHINT);
2357 operand(i, 1, ASM_OPER_MEM, bits, 20, 7);
2358 operand(i, 2, ASM_OPER_FREG, bits, 13, 7);
2361 asm_hint(i, ASM_CC_STHINT);
2362 operand(i, 1, ASM_OPER_MEM, bits, 20, 7);
2363 operand(i, 2, ASM_OPER_FREG, bits, 13, 7);
2364 s_immf(i, 3, bits, FRAG(6,7), FRAG(27,1), FRAG(36,1), 0);
2366 case ASM_FMT_M11: /* 2 dst */
2367 asm_hint(i, ASM_CC_LDHINT);
2368 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2369 operand(i, 2, ASM_OPER_FREG, bits, 13, 7);
2370 operand(i, 3, ASM_OPER_MEM, bits, 20, 7);
2373 case ASM_FMT_M12: /* 2 dst */
2374 asm_hint(i, ASM_CC_LDHINT);
2375 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2376 operand(i, 2, ASM_OPER_FREG, bits, 13, 7);
2377 operand(i, 3, ASM_OPER_MEM, bits, 20, 7);
2378 op_imm(i, 4, 8LL << FIELD(bits, 30, 1));
2382 asm_hint(i, ASM_CC_LFHINT);
2383 operand(i, 1, ASM_OPER_MEM, bits, 20, 7);
2385 case ASM_FMT_M14: /* 0 dst */
2386 asm_hint(i, ASM_CC_LFHINT);
2387 operand(i, 1, ASM_OPER_MEM, bits, 20, 7);
2388 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2391 case ASM_FMT_M15: /* 0 dst */
2392 asm_hint(i, ASM_CC_LFHINT);
2393 operand(i, 1, ASM_OPER_MEM, bits, 20, 7);
2394 s_immf(i, 2, bits, FRAG(13,7), FRAG(27,1), FRAG(36,1), 0);
2398 asm_hint(i, ASM_CC_LDHINT);
2399 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2400 operand(i, 2, ASM_OPER_MEM, bits, 20, 7);
2401 operand(i, 3, ASM_OPER_GREG, bits, 13, 7);
2402 if (i->i_op == ASM_OP_CMP8XCHG16) {
2403 op_type(i, 4, ASM_OPER_AREG);
2404 op_value(i, 4, AR_CSD);
2405 op_type(i, 5, ASM_OPER_AREG);
2406 op_value(i, 5, AR_CCV);
2408 if (FIELD(bits, 30, 6) < 8) {
2409 op_type(i, 4, ASM_OPER_AREG);
2410 op_value(i, 4, AR_CCV);
2415 asm_hint(i, ASM_CC_LDHINT);
2416 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2417 operand(i, 2, ASM_OPER_MEM, bits, 20, 7);
2418 switch (FIELD(bits, 13, 2)) {
2419 case 0: op_imm(i, 3, 1LL << 4); break;
2420 case 1: op_imm(i, 3, 1LL << 3); break;
2421 case 2: op_imm(i, 3, 1LL << 2); break;
2422 case 3: op_imm(i, 3, 1LL); break;
2424 if (FIELD(bits, 15, 1))
2425 i->i_oper[3].o_value *= -1LL;
2428 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2429 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2432 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2433 operand(i, 2, ASM_OPER_FREG, bits, 13, 7);
2435 case ASM_FMT_M20: /* 0 dst */
2436 operand(i, 1, ASM_OPER_GREG, bits, 13, 7);
2437 disp(i, 2, bits, FRAG(6,7), FRAG(20,13), FRAG(36,1), 0);
2440 case ASM_FMT_M21: /* 0 dst */
2441 operand(i, 1, ASM_OPER_FREG, bits, 13, 7);
2442 disp(i, 2, bits, FRAG(6,7), FRAG(20,13), FRAG(36,1), 0);
2445 case ASM_FMT_M22: /* 0 dst */
2446 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2447 disp(i, 2, bits, FRAG(13,20), FRAG(36,1), 0);
2450 case ASM_FMT_M23: /* 0 dst */
2451 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2452 disp(i, 2, bits, FRAG(13,20), FRAG(36,1), 0);
2459 if (FIELD(bits, 0, 6) != 0)
2464 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2467 operand(i, 1, ASM_OPER_FREG, bits, 6, 7);
2470 operand(i, 1, ASM_OPER_GREG, bits, 20, 7);
2473 operand(i, 1, ASM_OPER_AREG, bits, 20, 7);
2474 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2477 operand(i, 1, ASM_OPER_AREG, bits, 20, 7);
2478 s_immf(i, 2, bits, FRAG(13,7), FRAG(36,1), 0);
2481 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2482 operand(i, 2, ASM_OPER_AREG, bits, 20, 7);
2485 operand(i, 1, ASM_OPER_CREG, bits, 20, 7);
2486 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2489 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2490 operand(i, 2, ASM_OPER_CREG, bits, 20, 7);
2494 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2495 op_type(i, 2, ASM_OPER_AREG);
2496 op_value(i, 2, AR_PFS);
2497 loc = FIELD(bits, 20, 7);
2498 out = FIELD(bits, 13, 7) - loc;
2502 op_imm(i, 6, (uint64_t)FIELD(bits, 27, 4) << 3);
2506 if (FIELD(bits, 27, 6) == 0x2D)
2507 op_type(i, 1, ASM_OPER_PSR_L);
2509 op_type(i, 1, ASM_OPER_PSR_UM);
2510 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2513 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2514 if (FIELD(bits, 27, 6) == 0x25)
2515 op_type(i, 2, ASM_OPER_PSR);
2517 op_type(i, 2, ASM_OPER_PSR_UM);
2520 u_immf(i, 1, bits, FRAG(6,20), FRAG(36,1), 0);
2523 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2524 operand(i, 2, ASM_OPER_GREG, bits, 20, 7);
2525 operand(i, 3, ASM_OPER_GREG, bits, 13, 7);
2528 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2529 operand(i, 2, ASM_OPER_GREG, bits, 20, 7);
2530 u_imm(i, 3, bits, 13, 2);
2532 case ASM_FMT_M40: /* 0 dst */
2533 operand(i, 1, ASM_OPER_GREG, bits, 20, 7);
2534 u_imm(i, 2, bits, 13, 2);
2538 operand(i, 1, ASM_OPER_GREG, bits, 13, 7);
2541 operand(i, 1, ot, bits, 20, 7);
2542 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2545 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2546 operand(i, 2, ot, bits, 20, 7);
2549 u_immf(i, 1, bits, FRAG(6,21), FRAG(31,2), FRAG(36,1), 0);
2551 case ASM_FMT_M45: /* 0 dst */
2552 operand(i, 1, ASM_OPER_GREG, bits, 20, 7);
2553 operand(i, 2, ASM_OPER_GREG, bits, 13, 7);
2557 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2558 operand(i, 2, ASM_OPER_GREG, bits, 20, 7);
2561 operand(i, 1, ASM_OPER_GREG, bits, 20, 7);
2564 u_immf(i, 1, bits, FRAG(6,20), FRAG(36,1), 0);
2567 KASSERT(slot == 2, ("foo"));
2568 u_immf(i, 1, bits, FRAG(6,20), FRAG(36,1), 0);
2569 combine(&i->i_oper[1].o_value, 21, b->b_inst[1].i_bits, 41, 0);
2572 KASSERT(slot == 2, ("foo"));
2573 operand(i, 1, ASM_OPER_GREG, bits, 6, 7);
2574 u_immf(i, 2, bits, FRAG(13,7), FRAG(27,9), FRAG(22,5),
2576 combine(&i->i_oper[2].o_value, 22, b->b_inst[1].i_bits, 41, 0);
2577 combine(&i->i_oper[2].o_value, 63, bits, 1, 36);
2580 KASSERT(slot == 2, ("foo"));
2582 u_imm(i, 1, bits, 13, 20);
2583 combine(&i->i_oper[1].o_value, 20, b->b_inst[1].i_bits, 39, 2);
2584 combine(&i->i_oper[1].o_value, 59, bits, 1, 36);
2585 i->i_oper[1].o_value <<= 4;
2586 i->i_oper[1].o_type = ASM_OPER_DISP;
2589 KASSERT(slot == 2, ("foo"));
2591 operand(i, 1, ASM_OPER_BREG, bits, 6, 3);
2592 u_imm(i, 2, bits, 13, 20);
2593 combine(&i->i_oper[2].o_value, 20, b->b_inst[1].i_bits, 39, 2);
2594 combine(&i->i_oper[2].o_value, 59, bits, 1, 36);
2595 i->i_oper[2].o_value <<= 4;
2596 i->i_oper[2].o_type = ASM_OPER_DISP;
2599 KASSERT(slot == 2, ("foo"));
2600 u_immf(i, 1, bits, FRAG(6,20), FRAG(36,1), 0);
2601 combine(&i->i_oper[1].o_value, 21, b->b_inst[1].i_bits, 41, 0);
2604 KASSERT(fmt == ASM_FMT_NONE, ("foo"));