target/i386/tcg/emit.c.inc

   1 /*
   2  * New-style TCG opcode generator for i386 instructions
   3  *
   4  *  Copyright (c) 2022 Red Hat, Inc.
   5  *
   6  * Author: Paolo Bonzini <pbonzini@redhat.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 static void gen_NM_exception(DisasContext *s)
  23 {
  24     gen_exception(s, EXCP07_PREX);
  25 }
  26
  27 static void gen_illegal(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
  28 {
  29     gen_illegal_opcode(s);
  30 }
  31
  32 static void gen_load_ea(DisasContext *s, AddressParts *mem, bool is_vsib)
  33 {
  34     TCGv ea = gen_lea_modrm_1(s, *mem, is_vsib);
  35     gen_lea_v_seg(s, s->aflag, ea, mem->def_seg, s->override);
  36 }
  37
  38 static inline int mmx_offset(MemOp ot)
  39 {
  40     switch (ot) {
  41     case MO_8:
  42         return offsetof(MMXReg, MMX_B(0));
  43     case MO_16:
  44         return offsetof(MMXReg, MMX_W(0));
  45     case MO_32:
  46         return offsetof(MMXReg, MMX_L(0));
  47     case MO_64:
  48         return offsetof(MMXReg, MMX_Q(0));
  49     default:
  50         g_assert_not_reached();
  51     }
  52 }
  53
  54 static inline int xmm_offset(MemOp ot)
  55 {
  56     switch (ot) {
  57     case MO_8:
  58         return offsetof(ZMMReg, ZMM_B(0));
  59     case MO_16:
  60         return offsetof(ZMMReg, ZMM_W(0));
  61     case MO_32:
  62         return offsetof(ZMMReg, ZMM_L(0));
  63     case MO_64:
  64         return offsetof(ZMMReg, ZMM_Q(0));
  65     case MO_128:
  66         return offsetof(ZMMReg, ZMM_X(0));
  67     case MO_256:
  68         return offsetof(ZMMReg, ZMM_Y(0));
  69     default:
  70         g_assert_not_reached();
  71     }
  72 }
  73
  74 static int vector_reg_offset(X86DecodedOp *op)
  75 {
  76     assert(op->unit == X86_OP_MMX || op->unit == X86_OP_SSE);
  77
  78     if (op->unit == X86_OP_MMX) {
  79         return op->offset - mmx_offset(op->ot);
  80     } else {
  81         return op->offset - xmm_offset(op->ot);
  82     }
  83 }
  84
  85 static int vector_elem_offset(X86DecodedOp *op, MemOp ot, int n)
  86 {
  87     int base_ofs = vector_reg_offset(op);
  88     switch(ot) {
  89     case MO_8:
  90         if (op->unit == X86_OP_MMX) {
  91             return base_ofs + offsetof(MMXReg, MMX_B(n));
  92         } else {
  93             return base_ofs + offsetof(ZMMReg, ZMM_B(n));
  94         }
  95     case MO_16:
  96         if (op->unit == X86_OP_MMX) {
  97             return base_ofs + offsetof(MMXReg, MMX_W(n));
  98         } else {
  99             return base_ofs + offsetof(ZMMReg, ZMM_W(n));
 100         }
 101     case MO_32:
 102         if (op->unit == X86_OP_MMX) {
 103             return base_ofs + offsetof(MMXReg, MMX_L(n));
 104         } else {
 105             return base_ofs + offsetof(ZMMReg, ZMM_L(n));
 106         }
 107     case MO_64:
 108         if (op->unit == X86_OP_MMX) {
 109             return base_ofs;
 110         } else {
 111             return base_ofs + offsetof(ZMMReg, ZMM_Q(n));
 112         }
 113     case MO_128:
 114         assert(op->unit == X86_OP_SSE);
 115         return base_ofs + offsetof(ZMMReg, ZMM_X(n));
 116     case MO_256:
 117         assert(op->unit == X86_OP_SSE);
 118         return base_ofs + offsetof(ZMMReg, ZMM_Y(n));
 119     default:
 120         g_assert_not_reached();
 121     }
 122 }
 123
 124 static void compute_mmx_offset(X86DecodedOp *op)
 125 {
 126     if (!op->has_ea) {
 127         op->offset = offsetof(CPUX86State, fpregs[op->n].mmx) + mmx_offset(op->ot);
 128     } else {
 129         op->offset = offsetof(CPUX86State, mmx_t0) + mmx_offset(op->ot);
 130     }
 131 }
 132
 133 static void compute_xmm_offset(X86DecodedOp *op)
 134 {
 135     if (!op->has_ea) {
 136         op->offset = ZMM_OFFSET(op->n) + xmm_offset(op->ot);
 137     } else {
 138         op->offset = offsetof(CPUX86State, xmm_t0) + xmm_offset(op->ot);
 139     }
 140 }
 141
 142 static void gen_load_sse(DisasContext *s, TCGv temp, MemOp ot, int dest_ofs, bool aligned)
 143 {
 144     switch(ot) {
 145     case MO_8:
 146         gen_op_ld_v(s, MO_8, temp, s->A0);
 147         tcg_gen_st8_tl(temp, cpu_env, dest_ofs);
 148         break;
 149     case MO_16:
 150         gen_op_ld_v(s, MO_16, temp, s->A0);
 151         tcg_gen_st16_tl(temp, cpu_env, dest_ofs);
 152         break;
 153     case MO_32:
 154         gen_op_ld_v(s, MO_32, temp, s->A0);
 155         tcg_gen_st32_tl(temp, cpu_env, dest_ofs);
 156         break;
 157     case MO_64:
 158         gen_ldq_env_A0(s, dest_ofs);
 159         break;
 160     case MO_128:
 161         gen_ldo_env_A0(s, dest_ofs, aligned);
 162         break;
 163     case MO_256:
 164         gen_ldy_env_A0(s, dest_ofs, aligned);
 165         break;
 166     default:
 167         g_assert_not_reached();
 168     }
 169 }
 170
 171 static bool sse_needs_alignment(DisasContext *s, X86DecodedInsn *decode, MemOp ot)
 172 {
 173     switch (decode->e.vex_class) {
 174     case 2:
 175     case 4:
 176         if ((s->prefix & PREFIX_VEX) ||
 177             decode->e.vex_special == X86_VEX_SSEUnaligned) {
 178             /* MOST legacy SSE instructions require aligned memory operands, but not all.  */
 179             return false;
 180         }
 181         /* fall through */
 182     case 1:
 183         return ot >= MO_128;
 184
 185     default:
 186         return false;
 187     }
 188 }
 189
 190 static void gen_load(DisasContext *s, X86DecodedInsn *decode, int opn, TCGv v)
 191 {
 192     X86DecodedOp *op = &decode->op[opn];
 193
 194     switch (op->unit) {
 195     case X86_OP_SKIP:
 196         return;
 197     case X86_OP_SEG:
 198         tcg_gen_ld32u_tl(v, cpu_env,
 199                          offsetof(CPUX86State,segs[op->n].selector));
 200         break;
 201     case X86_OP_CR:
 202         tcg_gen_ld_tl(v, cpu_env, offsetof(CPUX86State, cr[op->n]));
 203         break;
 204     case X86_OP_DR:
 205         tcg_gen_ld_tl(v, cpu_env, offsetof(CPUX86State, dr[op->n]));
 206         break;
 207     case X86_OP_INT:
 208         if (op->has_ea) {
 209             gen_op_ld_v(s, op->ot, v, s->A0);
 210         } else {
 211             gen_op_mov_v_reg(s, op->ot, v, op->n);
 212         }
 213         break;
 214     case X86_OP_IMM:
 215         tcg_gen_movi_tl(v, decode->immediate);
 216         break;
 217
 218     case X86_OP_MMX:
 219         compute_mmx_offset(op);
 220         goto load_vector;
 221
 222     case X86_OP_SSE:
 223         compute_xmm_offset(op);
 224     load_vector:
 225         if (op->has_ea) {
 226             bool aligned = sse_needs_alignment(s, decode, op->ot);
 227             gen_load_sse(s, v, op->ot, op->offset, aligned);
 228         }
 229         break;
 230
 231     default:
 232         g_assert_not_reached();
 233     }
 234 }
 235
 236 static TCGv_ptr op_ptr(X86DecodedInsn *decode, int opn)
 237 {
 238     X86DecodedOp *op = &decode->op[opn];
 239     if (op->v_ptr) {
 240         return op->v_ptr;
 241     }
 242     op->v_ptr = tcg_temp_new_ptr();
 243
 244     /* The temporary points to the MMXReg or ZMMReg.  */
 245     tcg_gen_addi_ptr(op->v_ptr, cpu_env, vector_reg_offset(op));
 246     return op->v_ptr;
 247 }
 248
 249 #define OP_PTR0 op_ptr(decode, 0)
 250 #define OP_PTR1 op_ptr(decode, 1)
 251 #define OP_PTR2 op_ptr(decode, 2)
 252
 253 static void gen_writeback(DisasContext *s, X86DecodedInsn *decode, int opn, TCGv v)
 254 {
 255     X86DecodedOp *op = &decode->op[opn];
 256     switch (op->unit) {
 257     case X86_OP_SKIP:
 258         break;
 259     case X86_OP_SEG:
 260         /* Note that gen_movl_seg_T0 takes care of interrupt shadow and TF.  */
 261         gen_movl_seg_T0(s, op->n);
 262         break;
 263     case X86_OP_INT:
 264         if (op->has_ea) {
 265             gen_op_st_v(s, op->ot, v, s->A0);
 266         } else {
 267             gen_op_mov_reg_v(s, op->ot, op->n, v);
 268         }
 269         break;
 270     case X86_OP_MMX:
 271         break;
 272     case X86_OP_SSE:
 273         if ((s->prefix & PREFIX_VEX) && op->ot == MO_128) {
 274             tcg_gen_gvec_dup_imm(MO_64,
 275                                  offsetof(CPUX86State, xmm_regs[op->n].ZMM_X(1)),
 276                                  16, 16, 0);
 277         }
 278         break;
 279     case X86_OP_CR:
 280     case X86_OP_DR:
 281     default:
 282         g_assert_not_reached();
 283     }
 284 }
 285
 286 static inline int vector_len(DisasContext *s, X86DecodedInsn *decode)
 287 {
 288     if (decode->e.special == X86_SPECIAL_MMX &&
 289         !(s->prefix & (PREFIX_DATA | PREFIX_REPZ | PREFIX_REPNZ))) {
 290         return 8;
 291     }
 292     return s->vex_l ? 32 : 16;
 293 }
 294
 295 static void gen_store_sse(DisasContext *s, X86DecodedInsn *decode, int src_ofs)
 296 {
 297     MemOp ot = decode->op[0].ot;
 298     int vec_len = vector_len(s, decode);
 299     bool aligned = sse_needs_alignment(s, decode, ot);
 300
 301     if (!decode->op[0].has_ea) {
 302         tcg_gen_gvec_mov(MO_64, decode->op[0].offset, src_ofs, vec_len, vec_len);
 303         return;
 304     }
 305
 306     switch (ot) {
 307     case MO_64:
 308         gen_stq_env_A0(s, src_ofs);
 309         break;
 310     case MO_128:
 311         gen_sto_env_A0(s, src_ofs, aligned);
 312         break;
 313     case MO_256:
 314         gen_sty_env_A0(s, src_ofs, aligned);
 315         break;
 316     default:
 317         g_assert_not_reached();
 318     }
 319 }
 320
 321 #define BINARY_INT_GVEC(uname, func, ...)                                          \
 322 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 323 {                                                                                  \
 324     int vec_len = vector_len(s, decode);                                          \
 325                                                                                    \
 326     func(__VA_ARGS__,                                                              \
 327          decode->op[0].offset, decode->op[1].offset,                               \
 328          decode->op[2].offset, vec_len, vec_len);                                  \
 329 }
 330
 331 BINARY_INT_GVEC(PADDB,   tcg_gen_gvec_add, MO_8)
 332 BINARY_INT_GVEC(PADDW,   tcg_gen_gvec_add, MO_16)
 333 BINARY_INT_GVEC(PADDD,   tcg_gen_gvec_add, MO_32)
 334 BINARY_INT_GVEC(PADDSB,  tcg_gen_gvec_ssadd, MO_8)
 335 BINARY_INT_GVEC(PADDSW,  tcg_gen_gvec_ssadd, MO_16)
 336 BINARY_INT_GVEC(PADDUSB, tcg_gen_gvec_usadd, MO_8)
 337 BINARY_INT_GVEC(PADDUSW, tcg_gen_gvec_usadd, MO_16)
 338 BINARY_INT_GVEC(PAND,    tcg_gen_gvec_and, MO_64)
 339 BINARY_INT_GVEC(PCMPGTB, tcg_gen_gvec_cmp, TCG_COND_GT, MO_8)
 340 BINARY_INT_GVEC(PCMPGTW, tcg_gen_gvec_cmp, TCG_COND_GT, MO_16)
 341 BINARY_INT_GVEC(PCMPGTD, tcg_gen_gvec_cmp, TCG_COND_GT, MO_32)
 342 BINARY_INT_GVEC(PMAXSW,  tcg_gen_gvec_smax, MO_16)
 343 BINARY_INT_GVEC(PMAXUB,  tcg_gen_gvec_umax, MO_8)
 344 BINARY_INT_GVEC(PMINSW,  tcg_gen_gvec_smin, MO_16)
 345 BINARY_INT_GVEC(PMINUB,  tcg_gen_gvec_umin, MO_8)
 346 BINARY_INT_GVEC(POR,     tcg_gen_gvec_or, MO_64)
 347 BINARY_INT_GVEC(PSUBB,   tcg_gen_gvec_sub, MO_8)
 348 BINARY_INT_GVEC(PSUBW,   tcg_gen_gvec_sub, MO_16)
 349 BINARY_INT_GVEC(PSUBD,   tcg_gen_gvec_sub, MO_32)
 350 BINARY_INT_GVEC(PSUBQ,   tcg_gen_gvec_sub, MO_64)
 351 BINARY_INT_GVEC(PSUBSB,  tcg_gen_gvec_sssub, MO_8)
 352 BINARY_INT_GVEC(PSUBSW,  tcg_gen_gvec_sssub, MO_16)
 353 BINARY_INT_GVEC(PSUBUSB, tcg_gen_gvec_ussub, MO_8)
 354 BINARY_INT_GVEC(PSUBUSW, tcg_gen_gvec_ussub, MO_16)
 355 BINARY_INT_GVEC(PXOR,    tcg_gen_gvec_xor, MO_64)
 356
 357
 358 /*
 359  * 00 = p*  Pq, Qq (if mmx not NULL; no VEX)
 360  * 66 = vp* Vx, Hx, Wx
 361  *
 362  * These are really the same encoding, because 1) V is the same as P when VEX.V
 363  * is not present 2) P and Q are the same as H and W apart from MM/XMM
 364  */
 365 static inline void gen_binary_int_sse(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
 366                                       SSEFunc_0_eppp mmx, SSEFunc_0_eppp xmm, SSEFunc_0_eppp ymm)
 367 {
 368     assert(!!mmx == !!(decode->e.special == X86_SPECIAL_MMX));
 369
 370     if (mmx && (s->prefix & PREFIX_VEX) && !(s->prefix & PREFIX_DATA)) {
 371         /* VEX encoding is not applicable to MMX instructions.  */
 372         gen_illegal_opcode(s);
 373         return;
 374     }
 375     if (!(s->prefix & PREFIX_DATA)) {
 376         mmx(cpu_env, OP_PTR0, OP_PTR1, OP_PTR2);
 377     } else if (!s->vex_l) {
 378         xmm(cpu_env, OP_PTR0, OP_PTR1, OP_PTR2);
 379     } else {
 380         ymm(cpu_env, OP_PTR0, OP_PTR1, OP_PTR2);
 381     }
 382 }
 383
 384
 385 #define BINARY_INT_MMX(uname, lname)                                               \
 386 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 387 {                                                                                  \
 388     gen_binary_int_sse(s, env, decode,                                             \
 389                           gen_helper_##lname##_mmx,                                \
 390                           gen_helper_##lname##_xmm,                                \
 391                           gen_helper_##lname##_ymm);                               \
 392 }
 393 BINARY_INT_MMX(PUNPCKLBW,  punpcklbw)
 394 BINARY_INT_MMX(PUNPCKLWD,  punpcklwd)
 395 BINARY_INT_MMX(PUNPCKLDQ,  punpckldq)
 396 BINARY_INT_MMX(PACKSSWB,   packsswb)
 397 BINARY_INT_MMX(PACKUSWB,   packuswb)
 398 BINARY_INT_MMX(PUNPCKHBW,  punpckhbw)
 399 BINARY_INT_MMX(PUNPCKHWD,  punpckhwd)
 400 BINARY_INT_MMX(PUNPCKHDQ,  punpckhdq)
 401 BINARY_INT_MMX(PACKSSDW,   packssdw)
 402
 403 /* Instructions with no MMX equivalent.  */
 404 #define BINARY_INT_SSE(uname, lname)                                               \
 405 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 406 {                                                                                  \
 407     gen_binary_int_sse(s, env, decode,                                             \
 408                           NULL,                                                    \
 409                           gen_helper_##lname##_xmm,                                \
 410                           gen_helper_##lname##_ymm);                               \
 411 }
 412
 413 BINARY_INT_SSE(PUNPCKLQDQ, punpcklqdq)
 414 BINARY_INT_SSE(PUNPCKHQDQ, punpckhqdq)
 415
 416 static void gen_ADCOX(DisasContext *s, CPUX86State *env, MemOp ot, int cc_op)
 417 {
 418     TCGv carry_in = NULL;
 419     TCGv carry_out = (cc_op == CC_OP_ADCX ? cpu_cc_dst : cpu_cc_src2);
 420     TCGv zero;
 421
 422     if (cc_op == s->cc_op || s->cc_op == CC_OP_ADCOX) {
 423         /* Re-use the carry-out from a previous round.  */
 424         carry_in = carry_out;
 425         cc_op = s->cc_op;
 426     } else if (s->cc_op == CC_OP_ADCX || s->cc_op == CC_OP_ADOX) {
 427         /* Merge with the carry-out from the opposite instruction.  */
 428         cc_op = CC_OP_ADCOX;
 429     }
 430
 431     /* If we don't have a carry-in, get it out of EFLAGS.  */
 432     if (!carry_in) {
 433         if (s->cc_op != CC_OP_ADCX && s->cc_op != CC_OP_ADOX) {
 434             gen_compute_eflags(s);
 435         }
 436         carry_in = s->tmp0;
 437         tcg_gen_extract_tl(carry_in, cpu_cc_src,
 438             ctz32(cc_op == CC_OP_ADCX ? CC_C : CC_O), 1);
 439     }
 440
 441     switch (ot) {
 442 #ifdef TARGET_X86_64
 443     case MO_32:
 444         /* If TL is 64-bit just do everything in 64-bit arithmetic.  */
 445         tcg_gen_add_i64(s->T0, s->T0, s->T1);
 446         tcg_gen_add_i64(s->T0, s->T0, carry_in);
 447         tcg_gen_shri_i64(carry_out, s->T0, 32);
 448         break;
 449 #endif
 450     default:
 451         zero = tcg_constant_tl(0);
 452         tcg_gen_add2_tl(s->T0, carry_out, s->T0, zero, carry_in, zero);
 453         tcg_gen_add2_tl(s->T0, carry_out, s->T0, carry_out, s->T1, zero);
 454         break;
 455     }
 456     set_cc_op(s, cc_op);
 457 }
 458
 459 static void gen_ADCX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 460 {
 461     gen_ADCOX(s, env, decode->op[0].ot, CC_OP_ADCX);
 462 }
 463
 464 static void gen_ADOX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 465 {
 466     gen_ADCOX(s, env, decode->op[0].ot, CC_OP_ADOX);
 467 }
 468
 469 static void gen_ANDN(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 470 {
 471     MemOp ot = decode->op[0].ot;
 472
 473     tcg_gen_andc_tl(s->T0, s->T1, s->T0);
 474     gen_op_update1_cc(s);
 475     set_cc_op(s, CC_OP_LOGICB + ot);
 476 }
 477
 478 static void gen_BEXTR(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 479 {
 480     MemOp ot = decode->op[0].ot;
 481     TCGv bound, zero;
 482
 483     /*
 484      * Extract START, and shift the operand.
 485      * Shifts larger than operand size get zeros.
 486      */
 487     tcg_gen_ext8u_tl(s->A0, s->T1);
 488     tcg_gen_shr_tl(s->T0, s->T0, s->A0);
 489
 490     bound = tcg_constant_tl(ot == MO_64 ? 63 : 31);
 491     zero = tcg_constant_tl(0);
 492     tcg_gen_movcond_tl(TCG_COND_LEU, s->T0, s->A0, bound, s->T0, zero);
 493
 494     /*
 495      * Extract the LEN into a mask.  Lengths larger than
 496      * operand size get all ones.
 497      */
 498     tcg_gen_extract_tl(s->A0, s->T1, 8, 8);
 499     tcg_gen_movcond_tl(TCG_COND_LEU, s->A0, s->A0, bound, s->A0, bound);
 500
 501     tcg_gen_movi_tl(s->T1, 1);
 502     tcg_gen_shl_tl(s->T1, s->T1, s->A0);
 503     tcg_gen_subi_tl(s->T1, s->T1, 1);
 504     tcg_gen_and_tl(s->T0, s->T0, s->T1);
 505
 506     gen_op_update1_cc(s);
 507     set_cc_op(s, CC_OP_LOGICB + ot);
 508 }
 509
 510 static void gen_BLSI(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 511 {
 512     MemOp ot = decode->op[0].ot;
 513
 514     tcg_gen_neg_tl(s->T1, s->T0);
 515     tcg_gen_and_tl(s->T0, s->T0, s->T1);
 516     tcg_gen_mov_tl(cpu_cc_dst, s->T0);
 517     set_cc_op(s, CC_OP_BMILGB + ot);
 518 }
 519
 520 static void gen_BLSMSK(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 521 {
 522     MemOp ot = decode->op[0].ot;
 523
 524     tcg_gen_subi_tl(s->T1, s->T0, 1);
 525     tcg_gen_xor_tl(s->T0, s->T0, s->T1);
 526     tcg_gen_mov_tl(cpu_cc_dst, s->T0);
 527     set_cc_op(s, CC_OP_BMILGB + ot);
 528 }
 529
 530 static void gen_BLSR(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 531 {
 532     MemOp ot = decode->op[0].ot;
 533
 534     tcg_gen_subi_tl(s->T1, s->T0, 1);
 535     tcg_gen_and_tl(s->T0, s->T0, s->T1);
 536     tcg_gen_mov_tl(cpu_cc_dst, s->T0);
 537     set_cc_op(s, CC_OP_BMILGB + ot);
 538 }
 539
 540 static void gen_BZHI(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 541 {
 542     MemOp ot = decode->op[0].ot;
 543     TCGv bound;
 544
 545     tcg_gen_ext8u_tl(s->T1, cpu_regs[s->vex_v]);
 546     bound = tcg_constant_tl(ot == MO_64 ? 63 : 31);
 547
 548     /*
 549      * Note that since we're using BMILG (in order to get O
 550      * cleared) we need to store the inverse into C.
 551      */
 552     tcg_gen_setcond_tl(TCG_COND_LT, cpu_cc_src, s->T1, bound);
 553     tcg_gen_movcond_tl(TCG_COND_GT, s->T1, s->T1, bound, bound, s->T1);
 554
 555     tcg_gen_movi_tl(s->A0, -1);
 556     tcg_gen_shl_tl(s->A0, s->A0, s->T1);
 557     tcg_gen_andc_tl(s->T0, s->T0, s->A0);
 558
 559     gen_op_update1_cc(s);
 560     set_cc_op(s, CC_OP_BMILGB + ot);
 561 }
 562
 563 static void gen_CRC32(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 564 {
 565     MemOp ot = decode->op[2].ot;
 566
 567     tcg_gen_trunc_tl_i32(s->tmp2_i32, s->T0);
 568     gen_helper_crc32(s->T0, s->tmp2_i32, s->T1, tcg_constant_i32(8 << ot));
 569 }
 570
 571 static void gen_MOVBE(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 572 {
 573     MemOp ot = decode->op[0].ot;
 574
 575     /* M operand type does not load/store */
 576     if (decode->e.op0 == X86_TYPE_M) {
 577         tcg_gen_qemu_st_tl(s->T0, s->A0, s->mem_index, ot | MO_BE);
 578     } else {
 579         tcg_gen_qemu_ld_tl(s->T0, s->A0, s->mem_index, ot | MO_BE);
 580     }
 581 }
 582
 583 static void gen_MOVD_to(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 584 {
 585     MemOp ot = decode->op[2].ot;
 586     int vec_len = vector_len(s, decode);
 587     int lo_ofs = vector_elem_offset(&decode->op[0], ot, 0);
 588
 589     tcg_gen_gvec_dup_imm(MO_64, decode->op[0].offset, vec_len, vec_len, 0);
 590
 591     switch (ot) {
 592     case MO_32:
 593 #ifdef TARGET_X86_64
 594         tcg_gen_st32_tl(s->T1, cpu_env, lo_ofs);
 595         break;
 596     case MO_64:
 597 #endif
 598         tcg_gen_st_tl(s->T1, cpu_env, lo_ofs);
 599         break;
 600     default:
 601         g_assert_not_reached();
 602     }
 603 }
 604
 605 static void gen_MOVDQ(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 606 {
 607     gen_store_sse(s, decode, decode->op[2].offset);
 608 }
 609
 610 static void gen_MULX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 611 {
 612     MemOp ot = decode->op[0].ot;
 613
 614     /* low part of result in VEX.vvvv, high in MODRM */
 615     switch (ot) {
 616     default:
 617         tcg_gen_trunc_tl_i32(s->tmp2_i32, s->T0);
 618         tcg_gen_trunc_tl_i32(s->tmp3_i32, s->T1);
 619         tcg_gen_mulu2_i32(s->tmp2_i32, s->tmp3_i32,
 620                           s->tmp2_i32, s->tmp3_i32);
 621         tcg_gen_extu_i32_tl(cpu_regs[s->vex_v], s->tmp2_i32);
 622         tcg_gen_extu_i32_tl(s->T0, s->tmp3_i32);
 623         break;
 624 #ifdef TARGET_X86_64
 625     case MO_64:
 626         tcg_gen_mulu2_i64(cpu_regs[s->vex_v], s->T0, s->T0, s->T1);
 627         break;
 628 #endif
 629     }
 630
 631 }
 632
 633 static void gen_PANDN(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 634 {
 635     int vec_len = vector_len(s, decode);
 636
 637     /* Careful, operand order is reversed!  */
 638     tcg_gen_gvec_andc(MO_64,
 639                       decode->op[0].offset, decode->op[2].offset,
 640                       decode->op[1].offset, vec_len, vec_len);
 641 }
 642
 643 static void gen_PDEP(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 644 {
 645     MemOp ot = decode->op[1].ot;
 646     if (ot < MO_64) {
 647         tcg_gen_ext32u_tl(s->T0, s->T0);
 648     }
 649     gen_helper_pdep(s->T0, s->T0, s->T1);
 650 }
 651
 652 static void gen_PEXT(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 653 {
 654     MemOp ot = decode->op[1].ot;
 655     if (ot < MO_64) {
 656         tcg_gen_ext32u_tl(s->T0, s->T0);
 657     }
 658     gen_helper_pext(s->T0, s->T0, s->T1);
 659 }
 660
 661 static void gen_RORX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 662 {
 663     MemOp ot = decode->op[0].ot;
 664     int b = decode->immediate;
 665
 666     if (ot == MO_64) {
 667         tcg_gen_rotri_tl(s->T0, s->T0, b & 63);
 668     } else {
 669         tcg_gen_trunc_tl_i32(s->tmp2_i32, s->T0);
 670         tcg_gen_rotri_i32(s->tmp2_i32, s->tmp2_i32, b & 31);
 671         tcg_gen_extu_i32_tl(s->T0, s->tmp2_i32);
 672     }
 673 }
 674
 675 static void gen_SARX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 676 {
 677     MemOp ot = decode->op[0].ot;
 678     int mask;
 679
 680     mask = ot == MO_64 ? 63 : 31;
 681     tcg_gen_andi_tl(s->T1, s->T1, mask);
 682     if (ot != MO_64) {
 683         tcg_gen_ext32s_tl(s->T0, s->T0);
 684     }
 685     tcg_gen_sar_tl(s->T0, s->T0, s->T1);
 686 }
 687
 688 static void gen_SHLX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 689 {
 690     MemOp ot = decode->op[0].ot;
 691     int mask;
 692
 693     mask = ot == MO_64 ? 63 : 31;
 694     tcg_gen_andi_tl(s->T1, s->T1, mask);
 695     tcg_gen_shl_tl(s->T0, s->T0, s->T1);
 696 }
 697
 698 static void gen_SHRX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 699 {
 700     MemOp ot = decode->op[0].ot;
 701     int mask;
 702
 703     mask = ot == MO_64 ? 63 : 31;
 704     tcg_gen_andi_tl(s->T1, s->T1, mask);
 705     if (ot != MO_64) {
 706         tcg_gen_ext32u_tl(s->T0, s->T0);
 707     }
 708     tcg_gen_shr_tl(s->T0, s->T0, s->T1);
 709 }