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(PCMPGTB, tcg_gen_gvec_cmp, TCG_COND_GT, MO_8)
 332 BINARY_INT_GVEC(PCMPGTW, tcg_gen_gvec_cmp, TCG_COND_GT, MO_16)
 333 BINARY_INT_GVEC(PCMPGTD, tcg_gen_gvec_cmp, TCG_COND_GT, MO_32)
 334
 335
 336 /*
 337  * 00 = p*  Pq, Qq (if mmx not NULL; no VEX)
 338  * 66 = vp* Vx, Hx, Wx
 339  *
 340  * These are really the same encoding, because 1) V is the same as P when VEX.V
 341  * is not present 2) P and Q are the same as H and W apart from MM/XMM
 342  */
 343 static inline void gen_binary_int_sse(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
 344                                       SSEFunc_0_eppp mmx, SSEFunc_0_eppp xmm, SSEFunc_0_eppp ymm)
 345 {
 346     assert(!!mmx == !!(decode->e.special == X86_SPECIAL_MMX));
 347
 348     if (mmx && (s->prefix & PREFIX_VEX) && !(s->prefix & PREFIX_DATA)) {
 349         /* VEX encoding is not applicable to MMX instructions.  */
 350         gen_illegal_opcode(s);
 351         return;
 352     }
 353     if (!(s->prefix & PREFIX_DATA)) {
 354         mmx(cpu_env, OP_PTR0, OP_PTR1, OP_PTR2);
 355     } else if (!s->vex_l) {
 356         xmm(cpu_env, OP_PTR0, OP_PTR1, OP_PTR2);
 357     } else {
 358         ymm(cpu_env, OP_PTR0, OP_PTR1, OP_PTR2);
 359     }
 360 }
 361
 362
 363 #define BINARY_INT_MMX(uname, lname)                                               \
 364 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 365 {                                                                                  \
 366     gen_binary_int_sse(s, env, decode,                                             \
 367                           gen_helper_##lname##_mmx,                                \
 368                           gen_helper_##lname##_xmm,                                \
 369                           gen_helper_##lname##_ymm);                               \
 370 }
 371 BINARY_INT_MMX(PUNPCKLBW,  punpcklbw)
 372 BINARY_INT_MMX(PUNPCKLWD,  punpcklwd)
 373 BINARY_INT_MMX(PUNPCKLDQ,  punpckldq)
 374 BINARY_INT_MMX(PACKSSWB,   packsswb)
 375 BINARY_INT_MMX(PACKUSWB,   packuswb)
 376 BINARY_INT_MMX(PUNPCKHBW,  punpckhbw)
 377 BINARY_INT_MMX(PUNPCKHWD,  punpckhwd)
 378 BINARY_INT_MMX(PUNPCKHDQ,  punpckhdq)
 379 BINARY_INT_MMX(PACKSSDW,   packssdw)
 380
 381 /* Instructions with no MMX equivalent.  */
 382 #define BINARY_INT_SSE(uname, lname)                                               \
 383 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 384 {                                                                                  \
 385     gen_binary_int_sse(s, env, decode,                                             \
 386                           NULL,                                                    \
 387                           gen_helper_##lname##_xmm,                                \
 388                           gen_helper_##lname##_ymm);                               \
 389 }
 390
 391 BINARY_INT_SSE(PUNPCKLQDQ, punpcklqdq)
 392 BINARY_INT_SSE(PUNPCKHQDQ, punpckhqdq)
 393
 394 static void gen_ADCOX(DisasContext *s, CPUX86State *env, MemOp ot, int cc_op)
 395 {
 396     TCGv carry_in = NULL;
 397     TCGv carry_out = (cc_op == CC_OP_ADCX ? cpu_cc_dst : cpu_cc_src2);
 398     TCGv zero;
 399
 400     if (cc_op == s->cc_op || s->cc_op == CC_OP_ADCOX) {
 401         /* Re-use the carry-out from a previous round.  */
 402         carry_in = carry_out;
 403         cc_op = s->cc_op;
 404     } else if (s->cc_op == CC_OP_ADCX || s->cc_op == CC_OP_ADOX) {
 405         /* Merge with the carry-out from the opposite instruction.  */
 406         cc_op = CC_OP_ADCOX;
 407     }
 408
 409     /* If we don't have a carry-in, get it out of EFLAGS.  */
 410     if (!carry_in) {
 411         if (s->cc_op != CC_OP_ADCX && s->cc_op != CC_OP_ADOX) {
 412             gen_compute_eflags(s);
 413         }
 414         carry_in = s->tmp0;
 415         tcg_gen_extract_tl(carry_in, cpu_cc_src,
 416             ctz32(cc_op == CC_OP_ADCX ? CC_C : CC_O), 1);
 417     }
 418
 419     switch (ot) {
 420 #ifdef TARGET_X86_64
 421     case MO_32:
 422         /* If TL is 64-bit just do everything in 64-bit arithmetic.  */
 423         tcg_gen_add_i64(s->T0, s->T0, s->T1);
 424         tcg_gen_add_i64(s->T0, s->T0, carry_in);
 425         tcg_gen_shri_i64(carry_out, s->T0, 32);
 426         break;
 427 #endif
 428     default:
 429         zero = tcg_constant_tl(0);
 430         tcg_gen_add2_tl(s->T0, carry_out, s->T0, zero, carry_in, zero);
 431         tcg_gen_add2_tl(s->T0, carry_out, s->T0, carry_out, s->T1, zero);
 432         break;
 433     }
 434     set_cc_op(s, cc_op);
 435 }
 436
 437 static void gen_ADCX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 438 {
 439     gen_ADCOX(s, env, decode->op[0].ot, CC_OP_ADCX);
 440 }
 441
 442 static void gen_ADOX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 443 {
 444     gen_ADCOX(s, env, decode->op[0].ot, CC_OP_ADOX);
 445 }
 446
 447 static void gen_ANDN(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 448 {
 449     MemOp ot = decode->op[0].ot;
 450
 451     tcg_gen_andc_tl(s->T0, s->T1, s->T0);
 452     gen_op_update1_cc(s);
 453     set_cc_op(s, CC_OP_LOGICB + ot);
 454 }
 455
 456 static void gen_BEXTR(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 457 {
 458     MemOp ot = decode->op[0].ot;
 459     TCGv bound, zero;
 460
 461     /*
 462      * Extract START, and shift the operand.
 463      * Shifts larger than operand size get zeros.
 464      */
 465     tcg_gen_ext8u_tl(s->A0, s->T1);
 466     tcg_gen_shr_tl(s->T0, s->T0, s->A0);
 467
 468     bound = tcg_constant_tl(ot == MO_64 ? 63 : 31);
 469     zero = tcg_constant_tl(0);
 470     tcg_gen_movcond_tl(TCG_COND_LEU, s->T0, s->A0, bound, s->T0, zero);
 471
 472     /*
 473      * Extract the LEN into a mask.  Lengths larger than
 474      * operand size get all ones.
 475      */
 476     tcg_gen_extract_tl(s->A0, s->T1, 8, 8);
 477     tcg_gen_movcond_tl(TCG_COND_LEU, s->A0, s->A0, bound, s->A0, bound);
 478
 479     tcg_gen_movi_tl(s->T1, 1);
 480     tcg_gen_shl_tl(s->T1, s->T1, s->A0);
 481     tcg_gen_subi_tl(s->T1, s->T1, 1);
 482     tcg_gen_and_tl(s->T0, s->T0, s->T1);
 483
 484     gen_op_update1_cc(s);
 485     set_cc_op(s, CC_OP_LOGICB + ot);
 486 }
 487
 488 static void gen_BLSI(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 489 {
 490     MemOp ot = decode->op[0].ot;
 491
 492     tcg_gen_neg_tl(s->T1, s->T0);
 493     tcg_gen_and_tl(s->T0, s->T0, s->T1);
 494     tcg_gen_mov_tl(cpu_cc_dst, s->T0);
 495     set_cc_op(s, CC_OP_BMILGB + ot);
 496 }
 497
 498 static void gen_BLSMSK(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 499 {
 500     MemOp ot = decode->op[0].ot;
 501
 502     tcg_gen_subi_tl(s->T1, s->T0, 1);
 503     tcg_gen_xor_tl(s->T0, s->T0, s->T1);
 504     tcg_gen_mov_tl(cpu_cc_dst, s->T0);
 505     set_cc_op(s, CC_OP_BMILGB + ot);
 506 }
 507
 508 static void gen_BLSR(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 509 {
 510     MemOp ot = decode->op[0].ot;
 511
 512     tcg_gen_subi_tl(s->T1, s->T0, 1);
 513     tcg_gen_and_tl(s->T0, s->T0, s->T1);
 514     tcg_gen_mov_tl(cpu_cc_dst, s->T0);
 515     set_cc_op(s, CC_OP_BMILGB + ot);
 516 }
 517
 518 static void gen_BZHI(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 519 {
 520     MemOp ot = decode->op[0].ot;
 521     TCGv bound;
 522
 523     tcg_gen_ext8u_tl(s->T1, cpu_regs[s->vex_v]);
 524     bound = tcg_constant_tl(ot == MO_64 ? 63 : 31);
 525
 526     /*
 527      * Note that since we're using BMILG (in order to get O
 528      * cleared) we need to store the inverse into C.
 529      */
 530     tcg_gen_setcond_tl(TCG_COND_LT, cpu_cc_src, s->T1, bound);
 531     tcg_gen_movcond_tl(TCG_COND_GT, s->T1, s->T1, bound, bound, s->T1);
 532
 533     tcg_gen_movi_tl(s->A0, -1);
 534     tcg_gen_shl_tl(s->A0, s->A0, s->T1);
 535     tcg_gen_andc_tl(s->T0, s->T0, s->A0);
 536
 537     gen_op_update1_cc(s);
 538     set_cc_op(s, CC_OP_BMILGB + ot);
 539 }
 540
 541 static void gen_CRC32(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 542 {
 543     MemOp ot = decode->op[2].ot;
 544
 545     tcg_gen_trunc_tl_i32(s->tmp2_i32, s->T0);
 546     gen_helper_crc32(s->T0, s->tmp2_i32, s->T1, tcg_constant_i32(8 << ot));
 547 }
 548
 549 static void gen_MOVBE(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 550 {
 551     MemOp ot = decode->op[0].ot;
 552
 553     /* M operand type does not load/store */
 554     if (decode->e.op0 == X86_TYPE_M) {
 555         tcg_gen_qemu_st_tl(s->T0, s->A0, s->mem_index, ot | MO_BE);
 556     } else {
 557         tcg_gen_qemu_ld_tl(s->T0, s->A0, s->mem_index, ot | MO_BE);
 558     }
 559 }
 560
 561 static void gen_MOVD_to(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 562 {
 563     MemOp ot = decode->op[2].ot;
 564     int vec_len = vector_len(s, decode);
 565     int lo_ofs = vector_elem_offset(&decode->op[0], ot, 0);
 566
 567     tcg_gen_gvec_dup_imm(MO_64, decode->op[0].offset, vec_len, vec_len, 0);
 568
 569     switch (ot) {
 570     case MO_32:
 571 #ifdef TARGET_X86_64
 572         tcg_gen_st32_tl(s->T1, cpu_env, lo_ofs);
 573         break;
 574     case MO_64:
 575 #endif
 576         tcg_gen_st_tl(s->T1, cpu_env, lo_ofs);
 577         break;
 578     default:
 579         g_assert_not_reached();
 580     }
 581 }
 582
 583 static void gen_MOVDQ(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 584 {
 585     gen_store_sse(s, decode, decode->op[2].offset);
 586 }
 587
 588 static void gen_MULX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 589 {
 590     MemOp ot = decode->op[0].ot;
 591
 592     /* low part of result in VEX.vvvv, high in MODRM */
 593     switch (ot) {
 594     default:
 595         tcg_gen_trunc_tl_i32(s->tmp2_i32, s->T0);
 596         tcg_gen_trunc_tl_i32(s->tmp3_i32, s->T1);
 597         tcg_gen_mulu2_i32(s->tmp2_i32, s->tmp3_i32,
 598                           s->tmp2_i32, s->tmp3_i32);
 599         tcg_gen_extu_i32_tl(cpu_regs[s->vex_v], s->tmp2_i32);
 600         tcg_gen_extu_i32_tl(s->T0, s->tmp3_i32);
 601         break;
 602 #ifdef TARGET_X86_64
 603     case MO_64:
 604         tcg_gen_mulu2_i64(cpu_regs[s->vex_v], s->T0, s->T0, s->T1);
 605         break;
 606 #endif
 607     }
 608
 609 }
 610
 611 static void gen_PDEP(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 612 {
 613     MemOp ot = decode->op[1].ot;
 614     if (ot < MO_64) {
 615         tcg_gen_ext32u_tl(s->T0, s->T0);
 616     }
 617     gen_helper_pdep(s->T0, s->T0, s->T1);
 618 }
 619
 620 static void gen_PEXT(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 621 {
 622     MemOp ot = decode->op[1].ot;
 623     if (ot < MO_64) {
 624         tcg_gen_ext32u_tl(s->T0, s->T0);
 625     }
 626     gen_helper_pext(s->T0, s->T0, s->T1);
 627 }
 628
 629 static void gen_RORX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 630 {
 631     MemOp ot = decode->op[0].ot;
 632     int b = decode->immediate;
 633
 634     if (ot == MO_64) {
 635         tcg_gen_rotri_tl(s->T0, s->T0, b & 63);
 636     } else {
 637         tcg_gen_trunc_tl_i32(s->tmp2_i32, s->T0);
 638         tcg_gen_rotri_i32(s->tmp2_i32, s->tmp2_i32, b & 31);
 639         tcg_gen_extu_i32_tl(s->T0, s->tmp2_i32);
 640     }
 641 }
 642
 643 static void gen_SARX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 644 {
 645     MemOp ot = decode->op[0].ot;
 646     int mask;
 647
 648     mask = ot == MO_64 ? 63 : 31;
 649     tcg_gen_andi_tl(s->T1, s->T1, mask);
 650     if (ot != MO_64) {
 651         tcg_gen_ext32s_tl(s->T0, s->T0);
 652     }
 653     tcg_gen_sar_tl(s->T0, s->T0, s->T1);
 654 }
 655
 656 static void gen_SHLX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 657 {
 658     MemOp ot = decode->op[0].ot;
 659     int mask;
 660
 661     mask = ot == MO_64 ? 63 : 31;
 662     tcg_gen_andi_tl(s->T1, s->T1, mask);
 663     tcg_gen_shl_tl(s->T0, s->T0, s->T1);
 664 }
 665
 666 static void gen_SHRX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 667 {
 668     MemOp ot = decode->op[0].ot;
 669     int mask;
 670
 671     mask = ot == MO_64 ? 63 : 31;
 672     tcg_gen_andi_tl(s->T1, s->T1, mask);
 673     if (ot != MO_64) {
 674         tcg_gen_ext32u_tl(s->T0, s->T0);
 675     }
 676     tcg_gen_shr_tl(s->T0, s->T0, s->T1);
 677 }