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 #define ZMM_OFFSET(reg) offsetof(CPUX86State, xmm_regs[reg])
  23
  24 typedef void (*SSEFunc_i_ep)(TCGv_i32 val, TCGv_ptr env, TCGv_ptr reg);
  25 typedef void (*SSEFunc_l_ep)(TCGv_i64 val, TCGv_ptr env, TCGv_ptr reg);
  26 typedef void (*SSEFunc_0_epp)(TCGv_ptr env, TCGv_ptr reg_a, TCGv_ptr reg_b);
  27 typedef void (*SSEFunc_0_eppp)(TCGv_ptr env, TCGv_ptr reg_a, TCGv_ptr reg_b,
  28                                TCGv_ptr reg_c);
  29 typedef void (*SSEFunc_0_epppp)(TCGv_ptr env, TCGv_ptr reg_a, TCGv_ptr reg_b,
  30                                 TCGv_ptr reg_c, TCGv_ptr reg_d);
  31 typedef void (*SSEFunc_0_eppi)(TCGv_ptr env, TCGv_ptr reg_a, TCGv_ptr reg_b,
  32                                TCGv_i32 val);
  33 typedef void (*SSEFunc_0_epppi)(TCGv_ptr env, TCGv_ptr reg_a, TCGv_ptr reg_b,
  34                                 TCGv_ptr reg_c, TCGv_i32 val);
  35 typedef void (*SSEFunc_0_ppi)(TCGv_ptr reg_a, TCGv_ptr reg_b, TCGv_i32 val);
  36 typedef void (*SSEFunc_0_pppi)(TCGv_ptr reg_a, TCGv_ptr reg_b, TCGv_ptr reg_c,
  37                                TCGv_i32 val);
  38 typedef void (*SSEFunc_0_eppt)(TCGv_ptr env, TCGv_ptr reg_a, TCGv_ptr reg_b,
  39                                TCGv val);
  40 typedef void (*SSEFunc_0_epppti)(TCGv_ptr env, TCGv_ptr reg_a, TCGv_ptr reg_b,
  41                                  TCGv_ptr reg_c, TCGv a0, TCGv_i32 scale);
  42 typedef void (*SSEFunc_0_eppppi)(TCGv_ptr env, TCGv_ptr reg_a, TCGv_ptr reg_b,
  43                                   TCGv_ptr reg_c, TCGv_ptr reg_d, TCGv_i32 flags);
  44 typedef void (*SSEFunc_0_eppppii)(TCGv_ptr env, TCGv_ptr reg_a, TCGv_ptr reg_b,
  45                                   TCGv_ptr reg_c, TCGv_ptr reg_d, TCGv_i32 even,
  46                                   TCGv_i32 odd);
  47
  48 static inline TCGv_i32 tcg_constant8u_i32(uint8_t val)
  49 {
  50     return tcg_constant_i32(val);
  51 }
  52
  53 static void gen_NM_exception(DisasContext *s)
  54 {
  55     gen_exception(s, EXCP07_PREX);
  56 }
  57
  58 static void gen_load_ea(DisasContext *s, AddressParts *mem, bool is_vsib)
  59 {
  60     TCGv ea = gen_lea_modrm_1(s, *mem, is_vsib);
  61     gen_lea_v_seg(s, s->aflag, ea, mem->def_seg, s->override);
  62 }
  63
  64 static inline int mmx_offset(MemOp ot)
  65 {
  66     switch (ot) {
  67     case MO_8:
  68         return offsetof(MMXReg, MMX_B(0));
  69     case MO_16:
  70         return offsetof(MMXReg, MMX_W(0));
  71     case MO_32:
  72         return offsetof(MMXReg, MMX_L(0));
  73     case MO_64:
  74         return offsetof(MMXReg, MMX_Q(0));
  75     default:
  76         g_assert_not_reached();
  77     }
  78 }
  79
  80 static inline int xmm_offset(MemOp ot)
  81 {
  82     switch (ot) {
  83     case MO_8:
  84         return offsetof(ZMMReg, ZMM_B(0));
  85     case MO_16:
  86         return offsetof(ZMMReg, ZMM_W(0));
  87     case MO_32:
  88         return offsetof(ZMMReg, ZMM_L(0));
  89     case MO_64:
  90         return offsetof(ZMMReg, ZMM_Q(0));
  91     case MO_128:
  92         return offsetof(ZMMReg, ZMM_X(0));
  93     case MO_256:
  94         return offsetof(ZMMReg, ZMM_Y(0));
  95     default:
  96         g_assert_not_reached();
  97     }
  98 }
  99
 100 static int vector_reg_offset(X86DecodedOp *op)
 101 {
 102     assert(op->unit == X86_OP_MMX || op->unit == X86_OP_SSE);
 103
 104     if (op->unit == X86_OP_MMX) {
 105         return op->offset - mmx_offset(op->ot);
 106     } else {
 107         return op->offset - xmm_offset(op->ot);
 108     }
 109 }
 110
 111 static int vector_elem_offset(X86DecodedOp *op, MemOp ot, int n)
 112 {
 113     int base_ofs = vector_reg_offset(op);
 114     switch(ot) {
 115     case MO_8:
 116         if (op->unit == X86_OP_MMX) {
 117             return base_ofs + offsetof(MMXReg, MMX_B(n));
 118         } else {
 119             return base_ofs + offsetof(ZMMReg, ZMM_B(n));
 120         }
 121     case MO_16:
 122         if (op->unit == X86_OP_MMX) {
 123             return base_ofs + offsetof(MMXReg, MMX_W(n));
 124         } else {
 125             return base_ofs + offsetof(ZMMReg, ZMM_W(n));
 126         }
 127     case MO_32:
 128         if (op->unit == X86_OP_MMX) {
 129             return base_ofs + offsetof(MMXReg, MMX_L(n));
 130         } else {
 131             return base_ofs + offsetof(ZMMReg, ZMM_L(n));
 132         }
 133     case MO_64:
 134         if (op->unit == X86_OP_MMX) {
 135             return base_ofs;
 136         } else {
 137             return base_ofs + offsetof(ZMMReg, ZMM_Q(n));
 138         }
 139     case MO_128:
 140         assert(op->unit == X86_OP_SSE);
 141         return base_ofs + offsetof(ZMMReg, ZMM_X(n));
 142     case MO_256:
 143         assert(op->unit == X86_OP_SSE);
 144         return base_ofs + offsetof(ZMMReg, ZMM_Y(n));
 145     default:
 146         g_assert_not_reached();
 147     }
 148 }
 149
 150 static void compute_mmx_offset(X86DecodedOp *op)
 151 {
 152     if (!op->has_ea) {
 153         op->offset = offsetof(CPUX86State, fpregs[op->n].mmx) + mmx_offset(op->ot);
 154     } else {
 155         op->offset = offsetof(CPUX86State, mmx_t0) + mmx_offset(op->ot);
 156     }
 157 }
 158
 159 static void compute_xmm_offset(X86DecodedOp *op)
 160 {
 161     if (!op->has_ea) {
 162         op->offset = ZMM_OFFSET(op->n) + xmm_offset(op->ot);
 163     } else {
 164         op->offset = offsetof(CPUX86State, xmm_t0) + xmm_offset(op->ot);
 165     }
 166 }
 167
 168 static void gen_load_sse(DisasContext *s, TCGv temp, MemOp ot, int dest_ofs, bool aligned)
 169 {
 170     switch(ot) {
 171     case MO_8:
 172         gen_op_ld_v(s, MO_8, temp, s->A0);
 173         tcg_gen_st8_tl(temp, tcg_env, dest_ofs);
 174         break;
 175     case MO_16:
 176         gen_op_ld_v(s, MO_16, temp, s->A0);
 177         tcg_gen_st16_tl(temp, tcg_env, dest_ofs);
 178         break;
 179     case MO_32:
 180         gen_op_ld_v(s, MO_32, temp, s->A0);
 181         tcg_gen_st32_tl(temp, tcg_env, dest_ofs);
 182         break;
 183     case MO_64:
 184         gen_ldq_env_A0(s, dest_ofs);
 185         break;
 186     case MO_128:
 187         gen_ldo_env_A0(s, dest_ofs, aligned);
 188         break;
 189     case MO_256:
 190         gen_ldy_env_A0(s, dest_ofs, aligned);
 191         break;
 192     default:
 193         g_assert_not_reached();
 194     }
 195 }
 196
 197 static bool sse_needs_alignment(DisasContext *s, X86DecodedInsn *decode, MemOp ot)
 198 {
 199     switch (decode->e.vex_class) {
 200     case 2:
 201     case 4:
 202         if ((s->prefix & PREFIX_VEX) ||
 203             decode->e.vex_special == X86_VEX_SSEUnaligned) {
 204             /* MOST legacy SSE instructions require aligned memory operands, but not all.  */
 205             return false;
 206         }
 207         /* fall through */
 208     case 1:
 209         return ot >= MO_128;
 210
 211     default:
 212         return false;
 213     }
 214 }
 215
 216 static void gen_load(DisasContext *s, X86DecodedInsn *decode, int opn, TCGv v)
 217 {
 218     X86DecodedOp *op = &decode->op[opn];
 219
 220     switch (op->unit) {
 221     case X86_OP_SKIP:
 222         return;
 223     case X86_OP_SEG:
 224         tcg_gen_ld32u_tl(v, tcg_env,
 225                          offsetof(CPUX86State,segs[op->n].selector));
 226         break;
 227     case X86_OP_CR:
 228         tcg_gen_ld_tl(v, tcg_env, offsetof(CPUX86State, cr[op->n]));
 229         break;
 230     case X86_OP_DR:
 231         tcg_gen_ld_tl(v, tcg_env, offsetof(CPUX86State, dr[op->n]));
 232         break;
 233     case X86_OP_INT:
 234         if (op->has_ea) {
 235             gen_op_ld_v(s, op->ot, v, s->A0);
 236         } else {
 237             gen_op_mov_v_reg(s, op->ot, v, op->n);
 238         }
 239         break;
 240     case X86_OP_IMM:
 241         tcg_gen_movi_tl(v, decode->immediate);
 242         break;
 243
 244     case X86_OP_MMX:
 245         compute_mmx_offset(op);
 246         goto load_vector;
 247
 248     case X86_OP_SSE:
 249         compute_xmm_offset(op);
 250     load_vector:
 251         if (op->has_ea) {
 252             bool aligned = sse_needs_alignment(s, decode, op->ot);
 253             gen_load_sse(s, v, op->ot, op->offset, aligned);
 254         }
 255         break;
 256
 257     default:
 258         g_assert_not_reached();
 259     }
 260 }
 261
 262 static TCGv_ptr op_ptr(X86DecodedInsn *decode, int opn)
 263 {
 264     X86DecodedOp *op = &decode->op[opn];
 265     if (op->v_ptr) {
 266         return op->v_ptr;
 267     }
 268     op->v_ptr = tcg_temp_new_ptr();
 269
 270     /* The temporary points to the MMXReg or ZMMReg.  */
 271     tcg_gen_addi_ptr(op->v_ptr, tcg_env, vector_reg_offset(op));
 272     return op->v_ptr;
 273 }
 274
 275 #define OP_PTR0 op_ptr(decode, 0)
 276 #define OP_PTR1 op_ptr(decode, 1)
 277 #define OP_PTR2 op_ptr(decode, 2)
 278
 279 static void gen_writeback(DisasContext *s, X86DecodedInsn *decode, int opn, TCGv v)
 280 {
 281     X86DecodedOp *op = &decode->op[opn];
 282     switch (op->unit) {
 283     case X86_OP_SKIP:
 284         break;
 285     case X86_OP_SEG:
 286         /* Note that gen_movl_seg_T0 takes care of interrupt shadow and TF.  */
 287         gen_movl_seg_T0(s, op->n);
 288         break;
 289     case X86_OP_INT:
 290         if (op->has_ea) {
 291             gen_op_st_v(s, op->ot, v, s->A0);
 292         } else {
 293             gen_op_mov_reg_v(s, op->ot, op->n, v);
 294         }
 295         break;
 296     case X86_OP_MMX:
 297         break;
 298     case X86_OP_SSE:
 299         if (!op->has_ea && (s->prefix & PREFIX_VEX) && op->ot <= MO_128) {
 300             tcg_gen_gvec_dup_imm(MO_64,
 301                                  offsetof(CPUX86State, xmm_regs[op->n].ZMM_X(1)),
 302                                  16, 16, 0);
 303         }
 304         break;
 305     case X86_OP_CR:
 306     case X86_OP_DR:
 307     default:
 308         g_assert_not_reached();
 309     }
 310 }
 311
 312 static inline int vector_len(DisasContext *s, X86DecodedInsn *decode)
 313 {
 314     if (decode->e.special == X86_SPECIAL_MMX &&
 315         !(s->prefix & (PREFIX_DATA | PREFIX_REPZ | PREFIX_REPNZ))) {
 316         return 8;
 317     }
 318     return s->vex_l ? 32 : 16;
 319 }
 320
 321 static void gen_store_sse(DisasContext *s, X86DecodedInsn *decode, int src_ofs)
 322 {
 323     MemOp ot = decode->op[0].ot;
 324     int vec_len = vector_len(s, decode);
 325     bool aligned = sse_needs_alignment(s, decode, ot);
 326
 327     if (!decode->op[0].has_ea) {
 328         tcg_gen_gvec_mov(MO_64, decode->op[0].offset, src_ofs, vec_len, vec_len);
 329         return;
 330     }
 331
 332     switch (ot) {
 333     case MO_64:
 334         gen_stq_env_A0(s, src_ofs);
 335         break;
 336     case MO_128:
 337         gen_sto_env_A0(s, src_ofs, aligned);
 338         break;
 339     case MO_256:
 340         gen_sty_env_A0(s, src_ofs, aligned);
 341         break;
 342     default:
 343         g_assert_not_reached();
 344     }
 345 }
 346
 347 static void gen_helper_pavgusb(TCGv_ptr env, TCGv_ptr reg_a, TCGv_ptr reg_b)
 348 {
 349     gen_helper_pavgb_mmx(env, reg_a, reg_a, reg_b);
 350 }
 351
 352 #define FN_3DNOW_MOVE ((SSEFunc_0_epp) (uintptr_t) 1)
 353 static const SSEFunc_0_epp fns_3dnow[] = {
 354     [0x0c] = gen_helper_pi2fw,
 355     [0x0d] = gen_helper_pi2fd,
 356     [0x1c] = gen_helper_pf2iw,
 357     [0x1d] = gen_helper_pf2id,
 358     [0x8a] = gen_helper_pfnacc,
 359     [0x8e] = gen_helper_pfpnacc,
 360     [0x90] = gen_helper_pfcmpge,
 361     [0x94] = gen_helper_pfmin,
 362     [0x96] = gen_helper_pfrcp,
 363     [0x97] = gen_helper_pfrsqrt,
 364     [0x9a] = gen_helper_pfsub,
 365     [0x9e] = gen_helper_pfadd,
 366     [0xa0] = gen_helper_pfcmpgt,
 367     [0xa4] = gen_helper_pfmax,
 368     [0xa6] = FN_3DNOW_MOVE, /* PFRCPIT1; no need to actually increase precision */
 369     [0xa7] = FN_3DNOW_MOVE, /* PFRSQIT1 */
 370     [0xb6] = FN_3DNOW_MOVE, /* PFRCPIT2 */
 371     [0xaa] = gen_helper_pfsubr,
 372     [0xae] = gen_helper_pfacc,
 373     [0xb0] = gen_helper_pfcmpeq,
 374     [0xb4] = gen_helper_pfmul,
 375     [0xb7] = gen_helper_pmulhrw_mmx,
 376     [0xbb] = gen_helper_pswapd,
 377     [0xbf] = gen_helper_pavgusb,
 378 };
 379
 380 static void gen_3dnow(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
 381 {
 382     uint8_t b = decode->immediate;
 383     SSEFunc_0_epp fn = b < ARRAY_SIZE(fns_3dnow) ? fns_3dnow[b] : NULL;
 384
 385     if (!fn) {
 386         gen_illegal_opcode(s);
 387         return;
 388     }
 389     if (s->flags & HF_TS_MASK) {
 390         gen_NM_exception(s);
 391         return;
 392     }
 393     if (s->flags & HF_EM_MASK) {
 394         gen_illegal_opcode(s);
 395         return;
 396     }
 397
 398     gen_helper_enter_mmx(tcg_env);
 399     if (fn == FN_3DNOW_MOVE) {
 400        tcg_gen_ld_i64(s->tmp1_i64, tcg_env, decode->op[1].offset);
 401        tcg_gen_st_i64(s->tmp1_i64, tcg_env, decode->op[0].offset);
 402     } else {
 403        fn(tcg_env, OP_PTR0, OP_PTR1);
 404     }
 405 }
 406
 407 /*
 408  * 00 = v*ps Vps, Hps, Wpd
 409  * 66 = v*pd Vpd, Hpd, Wps
 410  * f3 = v*ss Vss, Hss, Wps
 411  * f2 = v*sd Vsd, Hsd, Wps
 412  */
 413 static inline void gen_unary_fp_sse(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
 414                               SSEFunc_0_epp pd_xmm, SSEFunc_0_epp ps_xmm,
 415                               SSEFunc_0_epp pd_ymm, SSEFunc_0_epp ps_ymm,
 416                               SSEFunc_0_eppp sd, SSEFunc_0_eppp ss)
 417 {
 418     if ((s->prefix & (PREFIX_REPZ | PREFIX_REPNZ)) != 0) {
 419         SSEFunc_0_eppp fn = s->prefix & PREFIX_REPZ ? ss : sd;
 420         if (!fn) {
 421             gen_illegal_opcode(s);
 422             return;
 423         }
 424         fn(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2);
 425     } else {
 426         SSEFunc_0_epp ps, pd, fn;
 427         ps = s->vex_l ? ps_ymm : ps_xmm;
 428         pd = s->vex_l ? pd_ymm : pd_xmm;
 429         fn = s->prefix & PREFIX_DATA ? pd : ps;
 430         if (!fn) {
 431             gen_illegal_opcode(s);
 432             return;
 433         }
 434         fn(tcg_env, OP_PTR0, OP_PTR2);
 435     }
 436 }
 437 #define UNARY_FP_SSE(uname, lname)                                                 \
 438 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 439 {                                                                                  \
 440     gen_unary_fp_sse(s, env, decode,                                               \
 441                      gen_helper_##lname##pd_xmm,                                   \
 442                      gen_helper_##lname##ps_xmm,                                   \
 443                      gen_helper_##lname##pd_ymm,                                   \
 444                      gen_helper_##lname##ps_ymm,                                   \
 445                      gen_helper_##lname##sd,                                       \
 446                      gen_helper_##lname##ss);                                      \
 447 }
 448 UNARY_FP_SSE(VSQRT, sqrt)
 449
 450 /*
 451  * 00 = v*ps Vps, Hps, Wpd
 452  * 66 = v*pd Vpd, Hpd, Wps
 453  * f3 = v*ss Vss, Hss, Wps
 454  * f2 = v*sd Vsd, Hsd, Wps
 455  */
 456 static inline void gen_fp_sse(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
 457                               SSEFunc_0_eppp pd_xmm, SSEFunc_0_eppp ps_xmm,
 458                               SSEFunc_0_eppp pd_ymm, SSEFunc_0_eppp ps_ymm,
 459                               SSEFunc_0_eppp sd, SSEFunc_0_eppp ss)
 460 {
 461     SSEFunc_0_eppp ps, pd, fn;
 462     if ((s->prefix & (PREFIX_REPZ | PREFIX_REPNZ)) != 0) {
 463         fn = s->prefix & PREFIX_REPZ ? ss : sd;
 464     } else {
 465         ps = s->vex_l ? ps_ymm : ps_xmm;
 466         pd = s->vex_l ? pd_ymm : pd_xmm;
 467         fn = s->prefix & PREFIX_DATA ? pd : ps;
 468     }
 469     if (fn) {
 470         fn(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2);
 471     } else {
 472         gen_illegal_opcode(s);
 473     }
 474 }
 475
 476 #define FP_SSE(uname, lname)                                                       \
 477 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 478 {                                                                                  \
 479     gen_fp_sse(s, env, decode,                                                     \
 480                gen_helper_##lname##pd_xmm,                                         \
 481                gen_helper_##lname##ps_xmm,                                         \
 482                gen_helper_##lname##pd_ymm,                                         \
 483                gen_helper_##lname##ps_ymm,                                         \
 484                gen_helper_##lname##sd,                                             \
 485                gen_helper_##lname##ss);                                            \
 486 }
 487 FP_SSE(VADD, add)
 488 FP_SSE(VMUL, mul)
 489 FP_SSE(VSUB, sub)
 490 FP_SSE(VMIN, min)
 491 FP_SSE(VDIV, div)
 492 FP_SSE(VMAX, max)
 493
 494 #define FMA_SSE_PACKED(uname, ptr0, ptr1, ptr2, even, odd)                         \
 495 static void gen_##uname##Px(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 496 {                                                                                  \
 497     SSEFunc_0_eppppii xmm = s->vex_w ? gen_helper_fma4pd_xmm : gen_helper_fma4ps_xmm; \
 498     SSEFunc_0_eppppii ymm = s->vex_w ? gen_helper_fma4pd_ymm : gen_helper_fma4ps_ymm; \
 499     SSEFunc_0_eppppii fn = s->vex_l ? ymm : xmm;                                   \
 500                                                                                    \
 501     fn(tcg_env, OP_PTR0, ptr0, ptr1, ptr2,                                         \
 502        tcg_constant_i32(even),                                                     \
 503        tcg_constant_i32((even) ^ (odd)));                                          \
 504 }
 505
 506 #define FMA_SSE(uname, ptr0, ptr1, ptr2, flags)                                    \
 507 FMA_SSE_PACKED(uname, ptr0, ptr1, ptr2, flags, flags)                              \
 508 static void gen_##uname##Sx(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 509 {                                                                                  \
 510     SSEFunc_0_eppppi fn = s->vex_w ? gen_helper_fma4sd : gen_helper_fma4ss;        \
 511                                                                                    \
 512     fn(tcg_env, OP_PTR0, ptr0, ptr1, ptr2,                                         \
 513        tcg_constant_i32(flags));                                                   \
 514 }                                                                                  \
 515
 516 FMA_SSE(VFMADD231,  OP_PTR1, OP_PTR2, OP_PTR0, 0)
 517 FMA_SSE(VFMADD213,  OP_PTR1, OP_PTR0, OP_PTR2, 0)
 518 FMA_SSE(VFMADD132,  OP_PTR0, OP_PTR2, OP_PTR1, 0)
 519
 520 FMA_SSE(VFNMADD231, OP_PTR1, OP_PTR2, OP_PTR0, float_muladd_negate_product)
 521 FMA_SSE(VFNMADD213, OP_PTR1, OP_PTR0, OP_PTR2, float_muladd_negate_product)
 522 FMA_SSE(VFNMADD132, OP_PTR0, OP_PTR2, OP_PTR1, float_muladd_negate_product)
 523
 524 FMA_SSE(VFMSUB231,  OP_PTR1, OP_PTR2, OP_PTR0, float_muladd_negate_c)
 525 FMA_SSE(VFMSUB213,  OP_PTR1, OP_PTR0, OP_PTR2, float_muladd_negate_c)
 526 FMA_SSE(VFMSUB132,  OP_PTR0, OP_PTR2, OP_PTR1, float_muladd_negate_c)
 527
 528 FMA_SSE(VFNMSUB231, OP_PTR1, OP_PTR2, OP_PTR0, float_muladd_negate_c|float_muladd_negate_product)
 529 FMA_SSE(VFNMSUB213, OP_PTR1, OP_PTR0, OP_PTR2, float_muladd_negate_c|float_muladd_negate_product)
 530 FMA_SSE(VFNMSUB132, OP_PTR0, OP_PTR2, OP_PTR1, float_muladd_negate_c|float_muladd_negate_product)
 531
 532 FMA_SSE_PACKED(VFMADDSUB231, OP_PTR1, OP_PTR2, OP_PTR0, float_muladd_negate_c, 0)
 533 FMA_SSE_PACKED(VFMADDSUB213, OP_PTR1, OP_PTR0, OP_PTR2, float_muladd_negate_c, 0)
 534 FMA_SSE_PACKED(VFMADDSUB132, OP_PTR0, OP_PTR2, OP_PTR1, float_muladd_negate_c, 0)
 535
 536 FMA_SSE_PACKED(VFMSUBADD231, OP_PTR1, OP_PTR2, OP_PTR0, 0, float_muladd_negate_c)
 537 FMA_SSE_PACKED(VFMSUBADD213, OP_PTR1, OP_PTR0, OP_PTR2, 0, float_muladd_negate_c)
 538 FMA_SSE_PACKED(VFMSUBADD132, OP_PTR0, OP_PTR2, OP_PTR1, 0, float_muladd_negate_c)
 539
 540 #define FP_UNPACK_SSE(uname, lname)                                                \
 541 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 542 {                                                                                  \
 543     /* PS maps to the DQ integer instruction, PD maps to QDQ.  */                  \
 544     gen_fp_sse(s, env, decode,                                                     \
 545                gen_helper_##lname##qdq_xmm,                                        \
 546                gen_helper_##lname##dq_xmm,                                         \
 547                gen_helper_##lname##qdq_ymm,                                        \
 548                gen_helper_##lname##dq_ymm,                                         \
 549                NULL, NULL);                                                        \
 550 }
 551 FP_UNPACK_SSE(VUNPCKLPx, punpckl)
 552 FP_UNPACK_SSE(VUNPCKHPx, punpckh)
 553
 554 /*
 555  * 00 = v*ps Vps, Wpd
 556  * f3 = v*ss Vss, Wps
 557  */
 558 static inline void gen_unary_fp32_sse(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
 559                                       SSEFunc_0_epp ps_xmm,
 560                                       SSEFunc_0_epp ps_ymm,
 561                                       SSEFunc_0_eppp ss)
 562 {
 563     if ((s->prefix & (PREFIX_DATA | PREFIX_REPNZ)) != 0) {
 564         goto illegal_op;
 565     } else if (s->prefix & PREFIX_REPZ) {
 566         if (!ss) {
 567             goto illegal_op;
 568         }
 569         ss(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2);
 570     } else {
 571         SSEFunc_0_epp fn = s->vex_l ? ps_ymm : ps_xmm;
 572         if (!fn) {
 573             goto illegal_op;
 574         }
 575         fn(tcg_env, OP_PTR0, OP_PTR2);
 576     }
 577     return;
 578
 579 illegal_op:
 580     gen_illegal_opcode(s);
 581 }
 582 #define UNARY_FP32_SSE(uname, lname)                                               \
 583 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 584 {                                                                                  \
 585     gen_unary_fp32_sse(s, env, decode,                                             \
 586                        gen_helper_##lname##ps_xmm,                                 \
 587                        gen_helper_##lname##ps_ymm,                                 \
 588                        gen_helper_##lname##ss);                                    \
 589 }
 590 UNARY_FP32_SSE(VRSQRT, rsqrt)
 591 UNARY_FP32_SSE(VRCP, rcp)
 592
 593 /*
 594  * 66 = v*pd Vpd, Hpd, Wpd
 595  * f2 = v*ps Vps, Hps, Wps
 596  */
 597 static inline void gen_horizontal_fp_sse(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
 598                                          SSEFunc_0_eppp pd_xmm, SSEFunc_0_eppp ps_xmm,
 599                                          SSEFunc_0_eppp pd_ymm, SSEFunc_0_eppp ps_ymm)
 600 {
 601     SSEFunc_0_eppp ps, pd, fn;
 602     ps = s->vex_l ? ps_ymm : ps_xmm;
 603     pd = s->vex_l ? pd_ymm : pd_xmm;
 604     fn = s->prefix & PREFIX_DATA ? pd : ps;
 605     fn(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2);
 606 }
 607 #define HORIZONTAL_FP_SSE(uname, lname)                                            \
 608 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 609 {                                                                                  \
 610     gen_horizontal_fp_sse(s, env, decode,                                          \
 611                           gen_helper_##lname##pd_xmm, gen_helper_##lname##ps_xmm,  \
 612                           gen_helper_##lname##pd_ymm, gen_helper_##lname##ps_ymm); \
 613 }
 614 HORIZONTAL_FP_SSE(VHADD, hadd)
 615 HORIZONTAL_FP_SSE(VHSUB, hsub)
 616 HORIZONTAL_FP_SSE(VADDSUB, addsub)
 617
 618 static inline void gen_ternary_sse(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
 619                                    int op3, SSEFunc_0_epppp xmm, SSEFunc_0_epppp ymm)
 620 {
 621     SSEFunc_0_epppp fn = s->vex_l ? ymm : xmm;
 622     TCGv_ptr ptr3 = tcg_temp_new_ptr();
 623
 624     /* The format of the fourth input is Lx */
 625     tcg_gen_addi_ptr(ptr3, tcg_env, ZMM_OFFSET(op3));
 626     fn(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2, ptr3);
 627 }
 628 #define TERNARY_SSE(uname, uvname, lname)                                          \
 629 static void gen_##uvname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 630 {                                                                                  \
 631     gen_ternary_sse(s, env, decode, (uint8_t)decode->immediate >> 4,               \
 632                     gen_helper_##lname##_xmm, gen_helper_##lname##_ymm);           \
 633 }                                                                                  \
 634 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 635 {                                                                                  \
 636     gen_ternary_sse(s, env, decode, 0,                                             \
 637                   gen_helper_##lname##_xmm, gen_helper_##lname##_ymm);             \
 638 }
 639 TERNARY_SSE(BLENDVPS, VBLENDVPS, blendvps)
 640 TERNARY_SSE(BLENDVPD, VBLENDVPD, blendvpd)
 641 TERNARY_SSE(PBLENDVB, VPBLENDVB, pblendvb)
 642
 643 static inline void gen_binary_imm_sse(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
 644                                       SSEFunc_0_epppi xmm, SSEFunc_0_epppi ymm)
 645 {
 646     TCGv_i32 imm = tcg_constant8u_i32(decode->immediate);
 647     if (!s->vex_l) {
 648         xmm(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2, imm);
 649     } else {
 650         ymm(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2, imm);
 651     }
 652 }
 653
 654 #define BINARY_IMM_SSE(uname, lname)                                               \
 655 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 656 {                                                                                  \
 657     gen_binary_imm_sse(s, env, decode,                                             \
 658                        gen_helper_##lname##_xmm,                                   \
 659                        gen_helper_##lname##_ymm);                                  \
 660 }
 661
 662 BINARY_IMM_SSE(VBLENDPD,   blendpd)
 663 BINARY_IMM_SSE(VBLENDPS,   blendps)
 664 BINARY_IMM_SSE(VPBLENDW,   pblendw)
 665 BINARY_IMM_SSE(VDDPS,      dpps)
 666 #define gen_helper_dppd_ymm NULL
 667 BINARY_IMM_SSE(VDDPD,      dppd)
 668 BINARY_IMM_SSE(VMPSADBW,   mpsadbw)
 669 BINARY_IMM_SSE(PCLMULQDQ,  pclmulqdq)
 670
 671
 672 #define UNARY_INT_GVEC(uname, func, ...)                                           \
 673 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 674 {                                                                                  \
 675     int vec_len = vector_len(s, decode);                                          \
 676                                                                                    \
 677     func(__VA_ARGS__, decode->op[0].offset,                                        \
 678          decode->op[2].offset, vec_len, vec_len);                                  \
 679 }
 680 UNARY_INT_GVEC(PABSB,          tcg_gen_gvec_abs, MO_8)
 681 UNARY_INT_GVEC(PABSW,          tcg_gen_gvec_abs, MO_16)
 682 UNARY_INT_GVEC(PABSD,          tcg_gen_gvec_abs, MO_32)
 683 UNARY_INT_GVEC(VBROADCASTx128, tcg_gen_gvec_dup_mem, MO_128)
 684 UNARY_INT_GVEC(VPBROADCASTB,   tcg_gen_gvec_dup_mem, MO_8)
 685 UNARY_INT_GVEC(VPBROADCASTW,   tcg_gen_gvec_dup_mem, MO_16)
 686 UNARY_INT_GVEC(VPBROADCASTD,   tcg_gen_gvec_dup_mem, MO_32)
 687 UNARY_INT_GVEC(VPBROADCASTQ,   tcg_gen_gvec_dup_mem, MO_64)
 688
 689
 690 #define BINARY_INT_GVEC(uname, func, ...)                                          \
 691 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 692 {                                                                                  \
 693     int vec_len = vector_len(s, decode);                                          \
 694                                                                                    \
 695     func(__VA_ARGS__,                                                              \
 696          decode->op[0].offset, decode->op[1].offset,                               \
 697          decode->op[2].offset, vec_len, vec_len);                                  \
 698 }
 699
 700 BINARY_INT_GVEC(PADDB,   tcg_gen_gvec_add, MO_8)
 701 BINARY_INT_GVEC(PADDW,   tcg_gen_gvec_add, MO_16)
 702 BINARY_INT_GVEC(PADDD,   tcg_gen_gvec_add, MO_32)
 703 BINARY_INT_GVEC(PADDQ,   tcg_gen_gvec_add, MO_64)
 704 BINARY_INT_GVEC(PADDSB,  tcg_gen_gvec_ssadd, MO_8)
 705 BINARY_INT_GVEC(PADDSW,  tcg_gen_gvec_ssadd, MO_16)
 706 BINARY_INT_GVEC(PADDUSB, tcg_gen_gvec_usadd, MO_8)
 707 BINARY_INT_GVEC(PADDUSW, tcg_gen_gvec_usadd, MO_16)
 708 BINARY_INT_GVEC(PAND,    tcg_gen_gvec_and, MO_64)
 709 BINARY_INT_GVEC(PCMPEQB, tcg_gen_gvec_cmp, TCG_COND_EQ, MO_8)
 710 BINARY_INT_GVEC(PCMPEQD, tcg_gen_gvec_cmp, TCG_COND_EQ, MO_32)
 711 BINARY_INT_GVEC(PCMPEQW, tcg_gen_gvec_cmp, TCG_COND_EQ, MO_16)
 712 BINARY_INT_GVEC(PCMPEQQ, tcg_gen_gvec_cmp, TCG_COND_EQ, MO_64)
 713 BINARY_INT_GVEC(PCMPGTB, tcg_gen_gvec_cmp, TCG_COND_GT, MO_8)
 714 BINARY_INT_GVEC(PCMPGTW, tcg_gen_gvec_cmp, TCG_COND_GT, MO_16)
 715 BINARY_INT_GVEC(PCMPGTD, tcg_gen_gvec_cmp, TCG_COND_GT, MO_32)
 716 BINARY_INT_GVEC(PCMPGTQ, tcg_gen_gvec_cmp, TCG_COND_GT, MO_64)
 717 BINARY_INT_GVEC(PMAXSB,  tcg_gen_gvec_smax, MO_8)
 718 BINARY_INT_GVEC(PMAXSW,  tcg_gen_gvec_smax, MO_16)
 719 BINARY_INT_GVEC(PMAXSD,  tcg_gen_gvec_smax, MO_32)
 720 BINARY_INT_GVEC(PMAXUB,  tcg_gen_gvec_umax, MO_8)
 721 BINARY_INT_GVEC(PMAXUW,  tcg_gen_gvec_umax, MO_16)
 722 BINARY_INT_GVEC(PMAXUD,  tcg_gen_gvec_umax, MO_32)
 723 BINARY_INT_GVEC(PMINSB,  tcg_gen_gvec_smin, MO_8)
 724 BINARY_INT_GVEC(PMINSW,  tcg_gen_gvec_smin, MO_16)
 725 BINARY_INT_GVEC(PMINSD,  tcg_gen_gvec_smin, MO_32)
 726 BINARY_INT_GVEC(PMINUB,  tcg_gen_gvec_umin, MO_8)
 727 BINARY_INT_GVEC(PMINUW,  tcg_gen_gvec_umin, MO_16)
 728 BINARY_INT_GVEC(PMINUD,  tcg_gen_gvec_umin, MO_32)
 729 BINARY_INT_GVEC(PMULLW,  tcg_gen_gvec_mul, MO_16)
 730 BINARY_INT_GVEC(PMULLD,  tcg_gen_gvec_mul, MO_32)
 731 BINARY_INT_GVEC(POR,     tcg_gen_gvec_or, MO_64)
 732 BINARY_INT_GVEC(PSUBB,   tcg_gen_gvec_sub, MO_8)
 733 BINARY_INT_GVEC(PSUBW,   tcg_gen_gvec_sub, MO_16)
 734 BINARY_INT_GVEC(PSUBD,   tcg_gen_gvec_sub, MO_32)
 735 BINARY_INT_GVEC(PSUBQ,   tcg_gen_gvec_sub, MO_64)
 736 BINARY_INT_GVEC(PSUBSB,  tcg_gen_gvec_sssub, MO_8)
 737 BINARY_INT_GVEC(PSUBSW,  tcg_gen_gvec_sssub, MO_16)
 738 BINARY_INT_GVEC(PSUBUSB, tcg_gen_gvec_ussub, MO_8)
 739 BINARY_INT_GVEC(PSUBUSW, tcg_gen_gvec_ussub, MO_16)
 740 BINARY_INT_GVEC(PXOR,    tcg_gen_gvec_xor, MO_64)
 741
 742
 743 /*
 744  * 00 = p*  Pq, Qq (if mmx not NULL; no VEX)
 745  * 66 = vp* Vx, Hx, Wx
 746  *
 747  * These are really the same encoding, because 1) V is the same as P when VEX.V
 748  * is not present 2) P and Q are the same as H and W apart from MM/XMM
 749  */
 750 static inline void gen_binary_int_sse(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
 751                                       SSEFunc_0_eppp mmx, SSEFunc_0_eppp xmm, SSEFunc_0_eppp ymm)
 752 {
 753     assert(!!mmx == !!(decode->e.special == X86_SPECIAL_MMX));
 754
 755     if (mmx && (s->prefix & PREFIX_VEX) && !(s->prefix & PREFIX_DATA)) {
 756         /* VEX encoding is not applicable to MMX instructions.  */
 757         gen_illegal_opcode(s);
 758         return;
 759     }
 760     if (!(s->prefix & PREFIX_DATA)) {
 761         mmx(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2);
 762     } else if (!s->vex_l) {
 763         xmm(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2);
 764     } else {
 765         ymm(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2);
 766     }
 767 }
 768
 769
 770 #define BINARY_INT_MMX(uname, lname)                                               \
 771 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 772 {                                                                                  \
 773     gen_binary_int_sse(s, env, decode,                                             \
 774                           gen_helper_##lname##_mmx,                                \
 775                           gen_helper_##lname##_xmm,                                \
 776                           gen_helper_##lname##_ymm);                               \
 777 }
 778 BINARY_INT_MMX(PUNPCKLBW,  punpcklbw)
 779 BINARY_INT_MMX(PUNPCKLWD,  punpcklwd)
 780 BINARY_INT_MMX(PUNPCKLDQ,  punpckldq)
 781 BINARY_INT_MMX(PACKSSWB,   packsswb)
 782 BINARY_INT_MMX(PACKUSWB,   packuswb)
 783 BINARY_INT_MMX(PUNPCKHBW,  punpckhbw)
 784 BINARY_INT_MMX(PUNPCKHWD,  punpckhwd)
 785 BINARY_INT_MMX(PUNPCKHDQ,  punpckhdq)
 786 BINARY_INT_MMX(PACKSSDW,   packssdw)
 787
 788 BINARY_INT_MMX(PAVGB,   pavgb)
 789 BINARY_INT_MMX(PAVGW,   pavgw)
 790 BINARY_INT_MMX(PMADDWD, pmaddwd)
 791 BINARY_INT_MMX(PMULHUW, pmulhuw)
 792 BINARY_INT_MMX(PMULHW,  pmulhw)
 793 BINARY_INT_MMX(PMULUDQ, pmuludq)
 794 BINARY_INT_MMX(PSADBW,  psadbw)
 795
 796 BINARY_INT_MMX(PSLLW_r, psllw)
 797 BINARY_INT_MMX(PSLLD_r, pslld)
 798 BINARY_INT_MMX(PSLLQ_r, psllq)
 799 BINARY_INT_MMX(PSRLW_r, psrlw)
 800 BINARY_INT_MMX(PSRLD_r, psrld)
 801 BINARY_INT_MMX(PSRLQ_r, psrlq)
 802 BINARY_INT_MMX(PSRAW_r, psraw)
 803 BINARY_INT_MMX(PSRAD_r, psrad)
 804
 805 BINARY_INT_MMX(PHADDW,    phaddw)
 806 BINARY_INT_MMX(PHADDSW,   phaddsw)
 807 BINARY_INT_MMX(PHADDD,    phaddd)
 808 BINARY_INT_MMX(PHSUBW,    phsubw)
 809 BINARY_INT_MMX(PHSUBSW,   phsubsw)
 810 BINARY_INT_MMX(PHSUBD,    phsubd)
 811 BINARY_INT_MMX(PMADDUBSW, pmaddubsw)
 812 BINARY_INT_MMX(PSHUFB,    pshufb)
 813 BINARY_INT_MMX(PSIGNB,    psignb)
 814 BINARY_INT_MMX(PSIGNW,    psignw)
 815 BINARY_INT_MMX(PSIGND,    psignd)
 816 BINARY_INT_MMX(PMULHRSW,  pmulhrsw)
 817
 818 /* Instructions with no MMX equivalent.  */
 819 #define BINARY_INT_SSE(uname, lname)                                               \
 820 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 821 {                                                                                  \
 822     gen_binary_int_sse(s, env, decode,                                             \
 823                           NULL,                                                    \
 824                           gen_helper_##lname##_xmm,                                \
 825                           gen_helper_##lname##_ymm);                               \
 826 }
 827
 828 /* Instructions with no MMX equivalent.  */
 829 BINARY_INT_SSE(PUNPCKLQDQ, punpcklqdq)
 830 BINARY_INT_SSE(PUNPCKHQDQ, punpckhqdq)
 831 BINARY_INT_SSE(VPACKUSDW,  packusdw)
 832 BINARY_INT_SSE(VPERMILPS,  vpermilps)
 833 BINARY_INT_SSE(VPERMILPD,  vpermilpd)
 834 BINARY_INT_SSE(VMASKMOVPS, vpmaskmovd)
 835 BINARY_INT_SSE(VMASKMOVPD, vpmaskmovq)
 836
 837 BINARY_INT_SSE(PMULDQ,    pmuldq)
 838
 839 BINARY_INT_SSE(VAESDEC, aesdec)
 840 BINARY_INT_SSE(VAESDECLAST, aesdeclast)
 841 BINARY_INT_SSE(VAESENC, aesenc)
 842 BINARY_INT_SSE(VAESENCLAST, aesenclast)
 843
 844 #define UNARY_CMP_SSE(uname, lname)                                                \
 845 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 846 {                                                                                  \
 847     if (!s->vex_l) {                                                               \
 848         gen_helper_##lname##_xmm(tcg_env, OP_PTR1, OP_PTR2);                       \
 849     } else {                                                                       \
 850         gen_helper_##lname##_ymm(tcg_env, OP_PTR1, OP_PTR2);                       \
 851     }                                                                              \
 852     set_cc_op(s, CC_OP_EFLAGS);                                                    \
 853 }
 854 UNARY_CMP_SSE(VPTEST,     ptest)
 855 UNARY_CMP_SSE(VTESTPS,    vtestps)
 856 UNARY_CMP_SSE(VTESTPD,    vtestpd)
 857
 858 static inline void gen_unary_int_sse(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
 859                                      SSEFunc_0_epp xmm, SSEFunc_0_epp ymm)
 860 {
 861     if (!s->vex_l) {
 862         xmm(tcg_env, OP_PTR0, OP_PTR2);
 863     } else {
 864         ymm(tcg_env, OP_PTR0, OP_PTR2);
 865     }
 866 }
 867
 868 #define UNARY_INT_SSE(uname, lname)                                                \
 869 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 870 {                                                                                  \
 871     gen_unary_int_sse(s, env, decode,                                              \
 872                       gen_helper_##lname##_xmm,                                    \
 873                       gen_helper_##lname##_ymm);                                   \
 874 }
 875
 876 UNARY_INT_SSE(VPMOVSXBW,    pmovsxbw)
 877 UNARY_INT_SSE(VPMOVSXBD,    pmovsxbd)
 878 UNARY_INT_SSE(VPMOVSXBQ,    pmovsxbq)
 879 UNARY_INT_SSE(VPMOVSXWD,    pmovsxwd)
 880 UNARY_INT_SSE(VPMOVSXWQ,    pmovsxwq)
 881 UNARY_INT_SSE(VPMOVSXDQ,    pmovsxdq)
 882
 883 UNARY_INT_SSE(VPMOVZXBW,    pmovzxbw)
 884 UNARY_INT_SSE(VPMOVZXBD,    pmovzxbd)
 885 UNARY_INT_SSE(VPMOVZXBQ,    pmovzxbq)
 886 UNARY_INT_SSE(VPMOVZXWD,    pmovzxwd)
 887 UNARY_INT_SSE(VPMOVZXWQ,    pmovzxwq)
 888 UNARY_INT_SSE(VPMOVZXDQ,    pmovzxdq)
 889
 890 UNARY_INT_SSE(VMOVSLDUP,    pmovsldup)
 891 UNARY_INT_SSE(VMOVSHDUP,    pmovshdup)
 892 UNARY_INT_SSE(VMOVDDUP,     pmovdldup)
 893
 894 UNARY_INT_SSE(VCVTDQ2PD, cvtdq2pd)
 895 UNARY_INT_SSE(VCVTPD2DQ, cvtpd2dq)
 896 UNARY_INT_SSE(VCVTTPD2DQ, cvttpd2dq)
 897 UNARY_INT_SSE(VCVTDQ2PS, cvtdq2ps)
 898 UNARY_INT_SSE(VCVTPS2DQ, cvtps2dq)
 899 UNARY_INT_SSE(VCVTTPS2DQ, cvttps2dq)
 900 UNARY_INT_SSE(VCVTPH2PS, cvtph2ps)
 901
 902
 903 static inline void gen_unary_imm_sse(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
 904                                      SSEFunc_0_ppi xmm, SSEFunc_0_ppi ymm)
 905 {
 906     TCGv_i32 imm = tcg_constant8u_i32(decode->immediate);
 907     if (!s->vex_l) {
 908         xmm(OP_PTR0, OP_PTR1, imm);
 909     } else {
 910         ymm(OP_PTR0, OP_PTR1, imm);
 911     }
 912 }
 913
 914 #define UNARY_IMM_SSE(uname, lname)                                                \
 915 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 916 {                                                                                  \
 917     gen_unary_imm_sse(s, env, decode,                                              \
 918                       gen_helper_##lname##_xmm,                                    \
 919                       gen_helper_##lname##_ymm);                                   \
 920 }
 921
 922 UNARY_IMM_SSE(PSHUFD,     pshufd)
 923 UNARY_IMM_SSE(PSHUFHW,    pshufhw)
 924 UNARY_IMM_SSE(PSHUFLW,    pshuflw)
 925 #define gen_helper_vpermq_xmm NULL
 926 UNARY_IMM_SSE(VPERMQ,      vpermq)
 927 UNARY_IMM_SSE(VPERMILPS_i, vpermilps_imm)
 928 UNARY_IMM_SSE(VPERMILPD_i, vpermilpd_imm)
 929
 930 static inline void gen_unary_imm_fp_sse(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
 931                                         SSEFunc_0_eppi xmm, SSEFunc_0_eppi ymm)
 932 {
 933     TCGv_i32 imm = tcg_constant8u_i32(decode->immediate);
 934     if (!s->vex_l) {
 935         xmm(tcg_env, OP_PTR0, OP_PTR1, imm);
 936     } else {
 937         ymm(tcg_env, OP_PTR0, OP_PTR1, imm);
 938     }
 939 }
 940
 941 #define UNARY_IMM_FP_SSE(uname, lname)                                             \
 942 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 943 {                                                                                  \
 944     gen_unary_imm_fp_sse(s, env, decode,                                           \
 945                       gen_helper_##lname##_xmm,                                    \
 946                       gen_helper_##lname##_ymm);                                   \
 947 }
 948
 949 UNARY_IMM_FP_SSE(VROUNDPS,    roundps)
 950 UNARY_IMM_FP_SSE(VROUNDPD,    roundpd)
 951
 952 static inline void gen_vexw_avx(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
 953                                 SSEFunc_0_eppp d_xmm, SSEFunc_0_eppp q_xmm,
 954                                 SSEFunc_0_eppp d_ymm, SSEFunc_0_eppp q_ymm)
 955 {
 956     SSEFunc_0_eppp d = s->vex_l ? d_ymm : d_xmm;
 957     SSEFunc_0_eppp q = s->vex_l ? q_ymm : q_xmm;
 958     SSEFunc_0_eppp fn = s->vex_w ? q : d;
 959     fn(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2);
 960 }
 961
 962 /* VEX.W affects whether to operate on 32- or 64-bit elements.  */
 963 #define VEXW_AVX(uname, lname)                                                     \
 964 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
 965 {                                                                                  \
 966     gen_vexw_avx(s, env, decode,                                                   \
 967                  gen_helper_##lname##d_xmm, gen_helper_##lname##q_xmm,             \
 968                  gen_helper_##lname##d_ymm, gen_helper_##lname##q_ymm);            \
 969 }
 970 VEXW_AVX(VPSLLV,    vpsllv)
 971 VEXW_AVX(VPSRLV,    vpsrlv)
 972 VEXW_AVX(VPSRAV,    vpsrav)
 973 VEXW_AVX(VPMASKMOV, vpmaskmov)
 974
 975 /* Same as above, but with extra arguments to the helper.  */
 976 static inline void gen_vsib_avx(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
 977                                 SSEFunc_0_epppti d_xmm, SSEFunc_0_epppti q_xmm,
 978                                 SSEFunc_0_epppti d_ymm, SSEFunc_0_epppti q_ymm)
 979 {
 980     SSEFunc_0_epppti d = s->vex_l ? d_ymm : d_xmm;
 981     SSEFunc_0_epppti q = s->vex_l ? q_ymm : q_xmm;
 982     SSEFunc_0_epppti fn = s->vex_w ? q : d;
 983     TCGv_i32 scale = tcg_constant_i32(decode->mem.scale);
 984     TCGv_ptr index = tcg_temp_new_ptr();
 985
 986     /* Pass third input as (index, base, scale) */
 987     tcg_gen_addi_ptr(index, tcg_env, ZMM_OFFSET(decode->mem.index));
 988     fn(tcg_env, OP_PTR0, OP_PTR1, index, s->A0, scale);
 989
 990     /*
 991      * There are two output operands, so zero OP1's high 128 bits
 992      * in the VEX.128 case.
 993      */
 994     if (!s->vex_l) {
 995         int ymmh_ofs = vector_elem_offset(&decode->op[1], MO_128, 1);
 996         tcg_gen_gvec_dup_imm(MO_64, ymmh_ofs, 16, 16, 0);
 997     }
 998 }
 999 #define VSIB_AVX(uname, lname)                                                     \
1000 static void gen_##uname(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode) \
1001 {                                                                                  \
1002     gen_vsib_avx(s, env, decode,                                                   \
1003                  gen_helper_##lname##d_xmm, gen_helper_##lname##q_xmm,             \
1004                  gen_helper_##lname##d_ymm, gen_helper_##lname##q_ymm);            \
1005 }
1006 VSIB_AVX(VPGATHERD, vpgatherd)
1007 VSIB_AVX(VPGATHERQ, vpgatherq)
1008
1009 static void gen_ADCOX(DisasContext *s, CPUX86State *env, MemOp ot, int cc_op)
1010 {
1011     int opposite_cc_op;
1012     TCGv carry_in = NULL;
1013     TCGv carry_out = (cc_op == CC_OP_ADCX ? cpu_cc_dst : cpu_cc_src2);
1014     TCGv zero;
1015
1016     if (cc_op == s->cc_op || s->cc_op == CC_OP_ADCOX) {
1017         /* Re-use the carry-out from a previous round.  */
1018         carry_in = carry_out;
1019     } else {
1020         /* We don't have a carry-in, get it out of EFLAGS.  */
1021         if (s->cc_op != CC_OP_ADCX && s->cc_op != CC_OP_ADOX) {
1022             gen_compute_eflags(s);
1023         }
1024         carry_in = s->tmp0;
1025         tcg_gen_extract_tl(carry_in, cpu_cc_src,
1026             ctz32(cc_op == CC_OP_ADCX ? CC_C : CC_O), 1);
1027     }
1028
1029     switch (ot) {
1030 #ifdef TARGET_X86_64
1031     case MO_32:
1032         /* If TL is 64-bit just do everything in 64-bit arithmetic.  */
1033         tcg_gen_ext32u_tl(s->T0, s->T0);
1034         tcg_gen_ext32u_tl(s->T1, s->T1);
1035         tcg_gen_add_i64(s->T0, s->T0, s->T1);
1036         tcg_gen_add_i64(s->T0, s->T0, carry_in);
1037         tcg_gen_shri_i64(carry_out, s->T0, 32);
1038         break;
1039 #endif
1040     default:
1041         zero = tcg_constant_tl(0);
1042         tcg_gen_add2_tl(s->T0, carry_out, s->T0, zero, carry_in, zero);
1043         tcg_gen_add2_tl(s->T0, carry_out, s->T0, carry_out, s->T1, zero);
1044         break;
1045     }
1046
1047     opposite_cc_op = cc_op == CC_OP_ADCX ? CC_OP_ADOX : CC_OP_ADCX;
1048     if (s->cc_op == CC_OP_ADCOX || s->cc_op == opposite_cc_op) {
1049         /* Merge with the carry-out from the opposite instruction.  */
1050         set_cc_op(s, CC_OP_ADCOX);
1051     } else {
1052         set_cc_op(s, cc_op);
1053     }
1054 }
1055
1056 static void gen_ADCX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1057 {
1058     gen_ADCOX(s, env, decode->op[0].ot, CC_OP_ADCX);
1059 }
1060
1061 static void gen_ADOX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1062 {
1063     gen_ADCOX(s, env, decode->op[0].ot, CC_OP_ADOX);
1064 }
1065
1066 static void gen_ANDN(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1067 {
1068     MemOp ot = decode->op[0].ot;
1069
1070     tcg_gen_andc_tl(s->T0, s->T1, s->T0);
1071     gen_op_update1_cc(s);
1072     set_cc_op(s, CC_OP_LOGICB + ot);
1073 }
1074
1075 static void gen_BEXTR(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1076 {
1077     MemOp ot = decode->op[0].ot;
1078     TCGv bound = tcg_constant_tl(ot == MO_64 ? 63 : 31);
1079     TCGv zero = tcg_constant_tl(0);
1080     TCGv mone = tcg_constant_tl(-1);
1081
1082     /*
1083      * Extract START, and shift the operand.
1084      * Shifts larger than operand size get zeros.
1085      */
1086     tcg_gen_ext8u_tl(s->A0, s->T1);
1087     if (TARGET_LONG_BITS == 64 && ot == MO_32) {
1088         tcg_gen_ext32u_tl(s->T0, s->T0);
1089     }
1090     tcg_gen_shr_tl(s->T0, s->T0, s->A0);
1091
1092     tcg_gen_movcond_tl(TCG_COND_LEU, s->T0, s->A0, bound, s->T0, zero);
1093
1094     /*
1095      * Extract the LEN into an inverse mask.  Lengths larger than
1096      * operand size get all zeros, length 0 gets all ones.
1097      */
1098     tcg_gen_extract_tl(s->A0, s->T1, 8, 8);
1099     tcg_gen_shl_tl(s->T1, mone, s->A0);
1100     tcg_gen_movcond_tl(TCG_COND_LEU, s->T1, s->A0, bound, s->T1, zero);
1101     tcg_gen_andc_tl(s->T0, s->T0, s->T1);
1102
1103     gen_op_update1_cc(s);
1104     set_cc_op(s, CC_OP_LOGICB + ot);
1105 }
1106
1107 static void gen_BLSI(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1108 {
1109     MemOp ot = decode->op[0].ot;
1110
1111     tcg_gen_mov_tl(cpu_cc_src, s->T0);
1112     tcg_gen_neg_tl(s->T1, s->T0);
1113     tcg_gen_and_tl(s->T0, s->T0, s->T1);
1114     tcg_gen_mov_tl(cpu_cc_dst, s->T0);
1115     set_cc_op(s, CC_OP_BMILGB + ot);
1116 }
1117
1118 static void gen_BLSMSK(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1119 {
1120     MemOp ot = decode->op[0].ot;
1121
1122     tcg_gen_mov_tl(cpu_cc_src, s->T0);
1123     tcg_gen_subi_tl(s->T1, s->T0, 1);
1124     tcg_gen_xor_tl(s->T0, s->T0, s->T1);
1125     tcg_gen_mov_tl(cpu_cc_dst, s->T0);
1126     set_cc_op(s, CC_OP_BMILGB + ot);
1127 }
1128
1129 static void gen_BLSR(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1130 {
1131     MemOp ot = decode->op[0].ot;
1132
1133     tcg_gen_mov_tl(cpu_cc_src, s->T0);
1134     tcg_gen_subi_tl(s->T1, s->T0, 1);
1135     tcg_gen_and_tl(s->T0, s->T0, s->T1);
1136     tcg_gen_mov_tl(cpu_cc_dst, s->T0);
1137     set_cc_op(s, CC_OP_BMILGB + ot);
1138 }
1139
1140 static void gen_BZHI(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1141 {
1142     MemOp ot = decode->op[0].ot;
1143     TCGv bound = tcg_constant_tl(ot == MO_64 ? 63 : 31);
1144     TCGv zero = tcg_constant_tl(0);
1145     TCGv mone = tcg_constant_tl(-1);
1146
1147     tcg_gen_ext8u_tl(s->T1, s->T1);
1148
1149     /*
1150      * Note that since we're using BMILG (in order to get O
1151      * cleared) we need to store the inverse into C.
1152      */
1153     tcg_gen_setcond_tl(TCG_COND_LEU, cpu_cc_src, s->T1, bound);
1154
1155     tcg_gen_shl_tl(s->A0, mone, s->T1);
1156     tcg_gen_movcond_tl(TCG_COND_LEU, s->A0, s->T1, bound, s->A0, zero);
1157     tcg_gen_andc_tl(s->T0, s->T0, s->A0);
1158
1159     gen_op_update1_cc(s);
1160     set_cc_op(s, CC_OP_BMILGB + ot);
1161 }
1162
1163 static void gen_CRC32(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1164 {
1165     MemOp ot = decode->op[2].ot;
1166
1167     tcg_gen_trunc_tl_i32(s->tmp2_i32, s->T0);
1168     gen_helper_crc32(s->T0, s->tmp2_i32, s->T1, tcg_constant_i32(8 << ot));
1169 }
1170
1171 static void gen_CVTPI2Px(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1172 {
1173     gen_helper_enter_mmx(tcg_env);
1174     if (s->prefix & PREFIX_DATA) {
1175         gen_helper_cvtpi2pd(tcg_env, OP_PTR0, OP_PTR2);
1176     } else {
1177         gen_helper_cvtpi2ps(tcg_env, OP_PTR0, OP_PTR2);
1178     }
1179 }
1180
1181 static void gen_CVTPx2PI(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1182 {
1183     gen_helper_enter_mmx(tcg_env);
1184     if (s->prefix & PREFIX_DATA) {
1185         gen_helper_cvtpd2pi(tcg_env, OP_PTR0, OP_PTR2);
1186     } else {
1187         gen_helper_cvtps2pi(tcg_env, OP_PTR0, OP_PTR2);
1188     }
1189 }
1190
1191 static void gen_CVTTPx2PI(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1192 {
1193     gen_helper_enter_mmx(tcg_env);
1194     if (s->prefix & PREFIX_DATA) {
1195         gen_helper_cvttpd2pi(tcg_env, OP_PTR0, OP_PTR2);
1196     } else {
1197         gen_helper_cvttps2pi(tcg_env, OP_PTR0, OP_PTR2);
1198     }
1199 }
1200
1201 static void gen_EMMS(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1202 {
1203     gen_helper_emms(tcg_env);
1204 }
1205
1206 static void gen_EXTRQ_i(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1207 {
1208     TCGv_i32 length = tcg_constant_i32(decode->immediate & 63);
1209     TCGv_i32 index = tcg_constant_i32((decode->immediate >> 8) & 63);
1210
1211     gen_helper_extrq_i(tcg_env, OP_PTR0, index, length);
1212 }
1213
1214 static void gen_EXTRQ_r(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1215 {
1216     gen_helper_extrq_r(tcg_env, OP_PTR0, OP_PTR2);
1217 }
1218
1219 static void gen_INSERTQ_i(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1220 {
1221     TCGv_i32 length = tcg_constant_i32(decode->immediate & 63);
1222     TCGv_i32 index = tcg_constant_i32((decode->immediate >> 8) & 63);
1223
1224     gen_helper_insertq_i(tcg_env, OP_PTR0, OP_PTR1, index, length);
1225 }
1226
1227 static void gen_INSERTQ_r(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1228 {
1229     gen_helper_insertq_r(tcg_env, OP_PTR0, OP_PTR2);
1230 }
1231
1232 static void gen_LDMXCSR(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1233 {
1234     tcg_gen_trunc_tl_i32(s->tmp2_i32, s->T1);
1235     gen_helper_ldmxcsr(tcg_env, s->tmp2_i32);
1236 }
1237
1238 static void gen_MASKMOV(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1239 {
1240     gen_lea_v_seg(s, s->aflag, cpu_regs[R_EDI], R_DS, s->override);
1241
1242     if (s->prefix & PREFIX_DATA) {
1243         gen_helper_maskmov_xmm(tcg_env, OP_PTR1, OP_PTR2, s->A0);
1244     } else {
1245         gen_helper_maskmov_mmx(tcg_env, OP_PTR1, OP_PTR2, s->A0);
1246     }
1247 }
1248
1249 static void gen_MOVBE(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1250 {
1251     MemOp ot = decode->op[0].ot;
1252
1253     /* M operand type does not load/store */
1254     if (decode->e.op0 == X86_TYPE_M) {
1255         tcg_gen_qemu_st_tl(s->T0, s->A0, s->mem_index, ot | MO_BE);
1256     } else {
1257         tcg_gen_qemu_ld_tl(s->T0, s->A0, s->mem_index, ot | MO_BE);
1258     }
1259 }
1260
1261 static void gen_MOVD_from(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1262 {
1263     MemOp ot = decode->op[2].ot;
1264
1265     switch (ot) {
1266     case MO_32:
1267 #ifdef TARGET_X86_64
1268         tcg_gen_ld32u_tl(s->T0, tcg_env, decode->op[2].offset);
1269         break;
1270     case MO_64:
1271 #endif
1272         tcg_gen_ld_tl(s->T0, tcg_env, decode->op[2].offset);
1273         break;
1274     default:
1275         abort();
1276     }
1277 }
1278
1279 static void gen_MOVD_to(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1280 {
1281     MemOp ot = decode->op[2].ot;
1282     int vec_len = vector_len(s, decode);
1283     int lo_ofs = vector_elem_offset(&decode->op[0], ot, 0);
1284
1285     tcg_gen_gvec_dup_imm(MO_64, decode->op[0].offset, vec_len, vec_len, 0);
1286
1287     switch (ot) {
1288     case MO_32:
1289 #ifdef TARGET_X86_64
1290         tcg_gen_st32_tl(s->T1, tcg_env, lo_ofs);
1291         break;
1292     case MO_64:
1293 #endif
1294         tcg_gen_st_tl(s->T1, tcg_env, lo_ofs);
1295         break;
1296     default:
1297         g_assert_not_reached();
1298     }
1299 }
1300
1301 static void gen_MOVDQ(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1302 {
1303     gen_store_sse(s, decode, decode->op[2].offset);
1304 }
1305
1306 static void gen_MOVMSK(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1307 {
1308     typeof(gen_helper_movmskps_ymm) *ps, *pd, *fn;
1309     ps = s->vex_l ? gen_helper_movmskps_ymm : gen_helper_movmskps_xmm;
1310     pd = s->vex_l ? gen_helper_movmskpd_ymm : gen_helper_movmskpd_xmm;
1311     fn = s->prefix & PREFIX_DATA ? pd : ps;
1312     fn(s->tmp2_i32, tcg_env, OP_PTR2);
1313     tcg_gen_extu_i32_tl(s->T0, s->tmp2_i32);
1314 }
1315
1316 static void gen_MOVQ(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1317 {
1318     int vec_len = vector_len(s, decode);
1319     int lo_ofs = vector_elem_offset(&decode->op[0], MO_64, 0);
1320
1321     tcg_gen_ld_i64(s->tmp1_i64, tcg_env, decode->op[2].offset);
1322     if (decode->op[0].has_ea) {
1323         tcg_gen_qemu_st_i64(s->tmp1_i64, s->A0, s->mem_index, MO_LEUQ);
1324     } else {
1325         /*
1326          * tcg_gen_gvec_dup_i64(MO_64, op0.offset, 8, vec_len, s->tmp1_64) would
1327          * seem to work, but it does not on big-endian platforms; the cleared parts
1328          * are always at higher addresses, but cross-endian emulation inverts the
1329          * byte order so that the cleared parts need to be at *lower* addresses.
1330          * Because oprsz is 8, we see this here even for SSE; but more in general,
1331          * it disqualifies using oprsz < maxsz to emulate VEX128.
1332          */
1333         tcg_gen_gvec_dup_imm(MO_64, decode->op[0].offset, vec_len, vec_len, 0);
1334         tcg_gen_st_i64(s->tmp1_i64, tcg_env, lo_ofs);
1335     }
1336 }
1337
1338 static void gen_MOVq_dq(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1339 {
1340     gen_helper_enter_mmx(tcg_env);
1341     /* Otherwise the same as any other movq.  */
1342     return gen_MOVQ(s, env, decode);
1343 }
1344
1345 static void gen_MULX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1346 {
1347     MemOp ot = decode->op[0].ot;
1348
1349     /* low part of result in VEX.vvvv, high in MODRM */
1350     switch (ot) {
1351     case MO_32:
1352 #ifdef TARGET_X86_64
1353         tcg_gen_trunc_tl_i32(s->tmp2_i32, s->T0);
1354         tcg_gen_trunc_tl_i32(s->tmp3_i32, s->T1);
1355         tcg_gen_mulu2_i32(s->tmp2_i32, s->tmp3_i32,
1356                           s->tmp2_i32, s->tmp3_i32);
1357         tcg_gen_extu_i32_tl(cpu_regs[s->vex_v], s->tmp2_i32);
1358         tcg_gen_extu_i32_tl(s->T0, s->tmp3_i32);
1359         break;
1360
1361     case MO_64:
1362 #endif
1363         tcg_gen_mulu2_tl(cpu_regs[s->vex_v], s->T0, s->T0, s->T1);
1364         break;
1365
1366     default:
1367         g_assert_not_reached();
1368     }
1369 }
1370
1371 static void gen_PALIGNR(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1372 {
1373     TCGv_i32 imm = tcg_constant8u_i32(decode->immediate);
1374     if (!(s->prefix & PREFIX_DATA)) {
1375         gen_helper_palignr_mmx(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2, imm);
1376     } else if (!s->vex_l) {
1377         gen_helper_palignr_xmm(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2, imm);
1378     } else {
1379         gen_helper_palignr_ymm(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2, imm);
1380     }
1381 }
1382
1383 static void gen_PANDN(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1384 {
1385     int vec_len = vector_len(s, decode);
1386
1387     /* Careful, operand order is reversed!  */
1388     tcg_gen_gvec_andc(MO_64,
1389                       decode->op[0].offset, decode->op[2].offset,
1390                       decode->op[1].offset, vec_len, vec_len);
1391 }
1392
1393 static void gen_PCMPESTRI(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1394 {
1395     TCGv_i32 imm = tcg_constant8u_i32(decode->immediate);
1396     gen_helper_pcmpestri_xmm(tcg_env, OP_PTR1, OP_PTR2, imm);
1397     set_cc_op(s, CC_OP_EFLAGS);
1398 }
1399
1400 static void gen_PCMPESTRM(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1401 {
1402     TCGv_i32 imm = tcg_constant8u_i32(decode->immediate);
1403     gen_helper_pcmpestrm_xmm(tcg_env, OP_PTR1, OP_PTR2, imm);
1404     set_cc_op(s, CC_OP_EFLAGS);
1405     if ((s->prefix & PREFIX_VEX) && !s->vex_l) {
1406         tcg_gen_gvec_dup_imm(MO_64, offsetof(CPUX86State, xmm_regs[0].ZMM_X(1)),
1407                              16, 16, 0);
1408     }
1409 }
1410
1411 static void gen_PCMPISTRI(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1412 {
1413     TCGv_i32 imm = tcg_constant8u_i32(decode->immediate);
1414     gen_helper_pcmpistri_xmm(tcg_env, OP_PTR1, OP_PTR2, imm);
1415     set_cc_op(s, CC_OP_EFLAGS);
1416 }
1417
1418 static void gen_PCMPISTRM(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1419 {
1420     TCGv_i32 imm = tcg_constant8u_i32(decode->immediate);
1421     gen_helper_pcmpistrm_xmm(tcg_env, OP_PTR1, OP_PTR2, imm);
1422     set_cc_op(s, CC_OP_EFLAGS);
1423     if ((s->prefix & PREFIX_VEX) && !s->vex_l) {
1424         tcg_gen_gvec_dup_imm(MO_64, offsetof(CPUX86State, xmm_regs[0].ZMM_X(1)),
1425                              16, 16, 0);
1426     }
1427 }
1428
1429 static void gen_PDEP(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1430 {
1431     MemOp ot = decode->op[1].ot;
1432     if (ot < MO_64) {
1433         tcg_gen_ext32u_tl(s->T0, s->T0);
1434     }
1435     gen_helper_pdep(s->T0, s->T0, s->T1);
1436 }
1437
1438 static void gen_PEXT(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1439 {
1440     MemOp ot = decode->op[1].ot;
1441     if (ot < MO_64) {
1442         tcg_gen_ext32u_tl(s->T0, s->T0);
1443     }
1444     gen_helper_pext(s->T0, s->T0, s->T1);
1445 }
1446
1447 static inline void gen_pextr(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode, MemOp ot)
1448 {
1449     int vec_len = vector_len(s, decode);
1450     int mask = (vec_len >> ot) - 1;
1451     int val = decode->immediate & mask;
1452
1453     switch (ot) {
1454     case MO_8:
1455         tcg_gen_ld8u_tl(s->T0, tcg_env, vector_elem_offset(&decode->op[1], ot, val));
1456         break;
1457     case MO_16:
1458         tcg_gen_ld16u_tl(s->T0, tcg_env, vector_elem_offset(&decode->op[1], ot, val));
1459         break;
1460     case MO_32:
1461 #ifdef TARGET_X86_64
1462         tcg_gen_ld32u_tl(s->T0, tcg_env, vector_elem_offset(&decode->op[1], ot, val));
1463         break;
1464     case MO_64:
1465 #endif
1466         tcg_gen_ld_tl(s->T0, tcg_env, vector_elem_offset(&decode->op[1], ot, val));
1467         break;
1468     default:
1469         abort();
1470     }
1471 }
1472
1473 static void gen_PEXTRB(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1474 {
1475     gen_pextr(s, env, decode, MO_8);
1476 }
1477
1478 static void gen_PEXTRW(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1479 {
1480     gen_pextr(s, env, decode, MO_16);
1481 }
1482
1483 static void gen_PEXTR(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1484 {
1485     MemOp ot = decode->op[0].ot;
1486     gen_pextr(s, env, decode, ot);
1487 }
1488
1489 static inline void gen_pinsr(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode, MemOp ot)
1490 {
1491     int vec_len = vector_len(s, decode);
1492     int mask = (vec_len >> ot) - 1;
1493     int val = decode->immediate & mask;
1494
1495     if (decode->op[1].offset != decode->op[0].offset) {
1496         assert(vec_len == 16);
1497         gen_store_sse(s, decode, decode->op[1].offset);
1498     }
1499
1500     switch (ot) {
1501     case MO_8:
1502         tcg_gen_st8_tl(s->T1, tcg_env, vector_elem_offset(&decode->op[0], ot, val));
1503         break;
1504     case MO_16:
1505         tcg_gen_st16_tl(s->T1, tcg_env, vector_elem_offset(&decode->op[0], ot, val));
1506         break;
1507     case MO_32:
1508 #ifdef TARGET_X86_64
1509         tcg_gen_st32_tl(s->T1, tcg_env, vector_elem_offset(&decode->op[0], ot, val));
1510         break;
1511     case MO_64:
1512 #endif
1513         tcg_gen_st_tl(s->T1, tcg_env, vector_elem_offset(&decode->op[0], ot, val));
1514         break;
1515     default:
1516         abort();
1517     }
1518 }
1519
1520 static void gen_PINSRB(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1521 {
1522     gen_pinsr(s, env, decode, MO_8);
1523 }
1524
1525 static void gen_PINSRW(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1526 {
1527     gen_pinsr(s, env, decode, MO_16);
1528 }
1529
1530 static void gen_PINSR(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1531 {
1532     gen_pinsr(s, env, decode, decode->op[2].ot);
1533 }
1534
1535 static void gen_pmovmskb_i64(TCGv_i64 d, TCGv_i64 s)
1536 {
1537     TCGv_i64 t = tcg_temp_new_i64();
1538
1539     tcg_gen_andi_i64(d, s, 0x8080808080808080ull);
1540
1541     /*
1542      * After each shift+or pair:
1543      * 0:  a.......b.......c.......d.......e.......f.......g.......h.......
1544      * 7:  ab......bc......cd......de......ef......fg......gh......h.......
1545      * 14: abcd....bcde....cdef....defg....efgh....fgh.....gh......h.......
1546      * 28: abcdefghbcdefgh.cdefgh..defgh...efgh....fgh.....gh......h.......
1547      * The result is left in the high bits of the word.
1548      */
1549     tcg_gen_shli_i64(t, d, 7);
1550     tcg_gen_or_i64(d, d, t);
1551     tcg_gen_shli_i64(t, d, 14);
1552     tcg_gen_or_i64(d, d, t);
1553     tcg_gen_shli_i64(t, d, 28);
1554     tcg_gen_or_i64(d, d, t);
1555 }
1556
1557 static void gen_pmovmskb_vec(unsigned vece, TCGv_vec d, TCGv_vec s)
1558 {
1559     TCGv_vec t = tcg_temp_new_vec_matching(d);
1560     TCGv_vec m = tcg_constant_vec_matching(d, MO_8, 0x80);
1561
1562     /* See above */
1563     tcg_gen_and_vec(vece, d, s, m);
1564     tcg_gen_shli_vec(vece, t, d, 7);
1565     tcg_gen_or_vec(vece, d, d, t);
1566     tcg_gen_shli_vec(vece, t, d, 14);
1567     tcg_gen_or_vec(vece, d, d, t);
1568     tcg_gen_shli_vec(vece, t, d, 28);
1569     tcg_gen_or_vec(vece, d, d, t);
1570 }
1571
1572 #ifdef TARGET_X86_64
1573 #define TCG_TARGET_HAS_extract2_tl TCG_TARGET_HAS_extract2_i64
1574 #else
1575 #define TCG_TARGET_HAS_extract2_tl TCG_TARGET_HAS_extract2_i32
1576 #endif
1577
1578 static void gen_PMOVMSKB(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1579 {
1580     static const TCGOpcode vecop_list[] = { INDEX_op_shli_vec, 0 };
1581     static const GVecGen2 g = {
1582         .fni8 = gen_pmovmskb_i64,
1583         .fniv = gen_pmovmskb_vec,
1584         .opt_opc = vecop_list,
1585         .vece = MO_64,
1586         .prefer_i64 = TCG_TARGET_REG_BITS == 64
1587     };
1588     MemOp ot = decode->op[2].ot;
1589     int vec_len = vector_len(s, decode);
1590     TCGv t = tcg_temp_new();
1591
1592     tcg_gen_gvec_2(offsetof(CPUX86State, xmm_t0) + xmm_offset(ot), decode->op[2].offset,
1593                    vec_len, vec_len, &g);
1594     tcg_gen_ld8u_tl(s->T0, tcg_env, offsetof(CPUX86State, xmm_t0.ZMM_B(vec_len - 1)));
1595     while (vec_len > 8) {
1596         vec_len -= 8;
1597         if (TCG_TARGET_HAS_extract2_tl) {
1598             /*
1599              * Load the next byte of the result into the high byte of T.
1600              * TCG does a similar expansion of deposit to shl+extract2; by
1601              * loading the whole word, the shift left is avoided.
1602              */
1603 #ifdef TARGET_X86_64
1604             tcg_gen_ld_tl(t, tcg_env, offsetof(CPUX86State, xmm_t0.ZMM_Q((vec_len - 1) / 8)));
1605 #else
1606             tcg_gen_ld_tl(t, tcg_env, offsetof(CPUX86State, xmm_t0.ZMM_L((vec_len - 1) / 4)));
1607 #endif
1608
1609             tcg_gen_extract2_tl(s->T0, t, s->T0, TARGET_LONG_BITS - 8);
1610         } else {
1611             /*
1612              * The _previous_ value is deposited into bits 8 and higher of t.  Because
1613              * those bits are known to be zero after ld8u, this becomes a shift+or
1614              * if deposit is not available.
1615              */
1616             tcg_gen_ld8u_tl(t, tcg_env, offsetof(CPUX86State, xmm_t0.ZMM_B(vec_len - 1)));
1617             tcg_gen_deposit_tl(s->T0, t, s->T0, 8, TARGET_LONG_BITS - 8);
1618         }
1619     }
1620 }
1621
1622 static void gen_PSHUFW(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1623 {
1624     TCGv_i32 imm = tcg_constant8u_i32(decode->immediate);
1625     gen_helper_pshufw_mmx(OP_PTR0, OP_PTR1, imm);
1626 }
1627
1628 static void gen_PSRLW_i(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1629 {
1630     int vec_len = vector_len(s, decode);
1631
1632     if (decode->immediate >= 16) {
1633         tcg_gen_gvec_dup_imm(MO_64, decode->op[0].offset, vec_len, vec_len, 0);
1634     } else {
1635         tcg_gen_gvec_shri(MO_16,
1636                           decode->op[0].offset, decode->op[1].offset,
1637                           decode->immediate, vec_len, vec_len);
1638     }
1639 }
1640
1641 static void gen_PSLLW_i(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1642 {
1643     int vec_len = vector_len(s, decode);
1644
1645     if (decode->immediate >= 16) {
1646         tcg_gen_gvec_dup_imm(MO_64, decode->op[0].offset, vec_len, vec_len, 0);
1647     } else {
1648         tcg_gen_gvec_shli(MO_16,
1649                           decode->op[0].offset, decode->op[1].offset,
1650                           decode->immediate, vec_len, vec_len);
1651     }
1652 }
1653
1654 static void gen_PSRAW_i(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1655 {
1656     int vec_len = vector_len(s, decode);
1657
1658     if (decode->immediate >= 16) {
1659         decode->immediate = 15;
1660     }
1661     tcg_gen_gvec_sari(MO_16,
1662                       decode->op[0].offset, decode->op[1].offset,
1663                       decode->immediate, vec_len, vec_len);
1664 }
1665
1666 static void gen_PSRLD_i(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1667 {
1668     int vec_len = vector_len(s, decode);
1669
1670     if (decode->immediate >= 32) {
1671         tcg_gen_gvec_dup_imm(MO_64, decode->op[0].offset, vec_len, vec_len, 0);
1672     } else {
1673         tcg_gen_gvec_shri(MO_32,
1674                           decode->op[0].offset, decode->op[1].offset,
1675                           decode->immediate, vec_len, vec_len);
1676     }
1677 }
1678
1679 static void gen_PSLLD_i(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1680 {
1681     int vec_len = vector_len(s, decode);
1682
1683     if (decode->immediate >= 32) {
1684         tcg_gen_gvec_dup_imm(MO_64, decode->op[0].offset, vec_len, vec_len, 0);
1685     } else {
1686         tcg_gen_gvec_shli(MO_32,
1687                           decode->op[0].offset, decode->op[1].offset,
1688                           decode->immediate, vec_len, vec_len);
1689     }
1690 }
1691
1692 static void gen_PSRAD_i(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1693 {
1694     int vec_len = vector_len(s, decode);
1695
1696     if (decode->immediate >= 32) {
1697         decode->immediate = 31;
1698     }
1699     tcg_gen_gvec_sari(MO_32,
1700                       decode->op[0].offset, decode->op[1].offset,
1701                       decode->immediate, vec_len, vec_len);
1702 }
1703
1704 static void gen_PSRLQ_i(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1705 {
1706     int vec_len = vector_len(s, decode);
1707
1708     if (decode->immediate >= 64) {
1709         tcg_gen_gvec_dup_imm(MO_64, decode->op[0].offset, vec_len, vec_len, 0);
1710     } else {
1711         tcg_gen_gvec_shri(MO_64,
1712                           decode->op[0].offset, decode->op[1].offset,
1713                           decode->immediate, vec_len, vec_len);
1714     }
1715 }
1716
1717 static void gen_PSLLQ_i(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1718 {
1719     int vec_len = vector_len(s, decode);
1720
1721     if (decode->immediate >= 64) {
1722         tcg_gen_gvec_dup_imm(MO_64, decode->op[0].offset, vec_len, vec_len, 0);
1723     } else {
1724         tcg_gen_gvec_shli(MO_64,
1725                           decode->op[0].offset, decode->op[1].offset,
1726                           decode->immediate, vec_len, vec_len);
1727     }
1728 }
1729
1730 static TCGv_ptr make_imm8u_xmm_vec(uint8_t imm, int vec_len)
1731 {
1732     MemOp ot = vec_len == 16 ? MO_128 : MO_256;
1733     TCGv_i32 imm_v = tcg_constant8u_i32(imm);
1734     TCGv_ptr ptr = tcg_temp_new_ptr();
1735
1736     tcg_gen_gvec_dup_imm(MO_64, offsetof(CPUX86State, xmm_t0) + xmm_offset(ot),
1737                          vec_len, vec_len, 0);
1738
1739     tcg_gen_addi_ptr(ptr, tcg_env, offsetof(CPUX86State, xmm_t0));
1740     tcg_gen_st_i32(imm_v, tcg_env, offsetof(CPUX86State, xmm_t0.ZMM_L(0)));
1741     return ptr;
1742 }
1743
1744 static void gen_PSRLDQ_i(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1745 {
1746     int vec_len = vector_len(s, decode);
1747     TCGv_ptr imm_vec = make_imm8u_xmm_vec(decode->immediate, vec_len);
1748
1749     if (s->vex_l) {
1750         gen_helper_psrldq_ymm(tcg_env, OP_PTR0, OP_PTR1, imm_vec);
1751     } else {
1752         gen_helper_psrldq_xmm(tcg_env, OP_PTR0, OP_PTR1, imm_vec);
1753     }
1754 }
1755
1756 static void gen_PSLLDQ_i(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1757 {
1758     int vec_len = vector_len(s, decode);
1759     TCGv_ptr imm_vec = make_imm8u_xmm_vec(decode->immediate, vec_len);
1760
1761     if (s->vex_l) {
1762         gen_helper_pslldq_ymm(tcg_env, OP_PTR0, OP_PTR1, imm_vec);
1763     } else {
1764         gen_helper_pslldq_xmm(tcg_env, OP_PTR0, OP_PTR1, imm_vec);
1765     }
1766 }
1767
1768 static void gen_RORX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1769 {
1770     MemOp ot = decode->op[0].ot;
1771     int mask = ot == MO_64 ? 63 : 31;
1772     int b = decode->immediate & mask;
1773
1774     switch (ot) {
1775     case MO_32:
1776 #ifdef TARGET_X86_64
1777         tcg_gen_trunc_tl_i32(s->tmp2_i32, s->T0);
1778         tcg_gen_rotri_i32(s->tmp2_i32, s->tmp2_i32, b);
1779         tcg_gen_extu_i32_tl(s->T0, s->tmp2_i32);
1780         break;
1781
1782     case MO_64:
1783 #endif
1784         tcg_gen_rotri_tl(s->T0, s->T0, b);
1785         break;
1786
1787     default:
1788         g_assert_not_reached();
1789     }
1790 }
1791
1792 static void gen_SARX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1793 {
1794     MemOp ot = decode->op[0].ot;
1795     int mask;
1796
1797     mask = ot == MO_64 ? 63 : 31;
1798     tcg_gen_andi_tl(s->T1, s->T1, mask);
1799     if (ot != MO_64) {
1800         tcg_gen_ext32s_tl(s->T0, s->T0);
1801     }
1802     tcg_gen_sar_tl(s->T0, s->T0, s->T1);
1803 }
1804
1805 static void gen_SHA1NEXTE(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1806 {
1807     gen_helper_sha1nexte(OP_PTR0, OP_PTR1, OP_PTR2);
1808 }
1809
1810 static void gen_SHA1MSG1(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1811 {
1812     gen_helper_sha1msg1(OP_PTR0, OP_PTR1, OP_PTR2);
1813 }
1814
1815 static void gen_SHA1MSG2(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1816 {
1817     gen_helper_sha1msg2(OP_PTR0, OP_PTR1, OP_PTR2);
1818 }
1819
1820 static void gen_SHA1RNDS4(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1821 {
1822     switch(decode->immediate & 3) {
1823     case 0:
1824         gen_helper_sha1rnds4_f0(OP_PTR0, OP_PTR0, OP_PTR1);
1825         break;
1826     case 1:
1827         gen_helper_sha1rnds4_f1(OP_PTR0, OP_PTR0, OP_PTR1);
1828         break;
1829     case 2:
1830         gen_helper_sha1rnds4_f2(OP_PTR0, OP_PTR0, OP_PTR1);
1831         break;
1832     case 3:
1833         gen_helper_sha1rnds4_f3(OP_PTR0, OP_PTR0, OP_PTR1);
1834         break;
1835     }
1836 }
1837
1838 static void gen_SHA256MSG1(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1839 {
1840     gen_helper_sha256msg1(OP_PTR0, OP_PTR1, OP_PTR2);
1841 }
1842
1843 static void gen_SHA256MSG2(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1844 {
1845     gen_helper_sha256msg2(OP_PTR0, OP_PTR1, OP_PTR2);
1846 }
1847
1848 static void gen_SHA256RNDS2(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1849 {
1850     TCGv_i32 wk0 = tcg_temp_new_i32();
1851     TCGv_i32 wk1 = tcg_temp_new_i32();
1852
1853     tcg_gen_ld_i32(wk0, tcg_env, ZMM_OFFSET(0) + offsetof(ZMMReg, ZMM_L(0)));
1854     tcg_gen_ld_i32(wk1, tcg_env, ZMM_OFFSET(0) + offsetof(ZMMReg, ZMM_L(1)));
1855
1856     gen_helper_sha256rnds2(OP_PTR0, OP_PTR1, OP_PTR2, wk0, wk1);
1857 }
1858
1859 static void gen_SHLX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1860 {
1861     MemOp ot = decode->op[0].ot;
1862     int mask;
1863
1864     mask = ot == MO_64 ? 63 : 31;
1865     tcg_gen_andi_tl(s->T1, s->T1, mask);
1866     tcg_gen_shl_tl(s->T0, s->T0, s->T1);
1867 }
1868
1869 static void gen_SHRX(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1870 {
1871     MemOp ot = decode->op[0].ot;
1872     int mask;
1873
1874     mask = ot == MO_64 ? 63 : 31;
1875     tcg_gen_andi_tl(s->T1, s->T1, mask);
1876     if (ot != MO_64) {
1877         tcg_gen_ext32u_tl(s->T0, s->T0);
1878     }
1879     tcg_gen_shr_tl(s->T0, s->T0, s->T1);
1880 }
1881
1882 static void gen_VAESKEYGEN(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1883 {
1884     TCGv_i32 imm = tcg_constant8u_i32(decode->immediate);
1885     assert(!s->vex_l);
1886     gen_helper_aeskeygenassist_xmm(tcg_env, OP_PTR0, OP_PTR1, imm);
1887 }
1888
1889 static void gen_STMXCSR(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1890 {
1891     gen_helper_update_mxcsr(tcg_env);
1892     tcg_gen_ld32u_tl(s->T0, tcg_env, offsetof(CPUX86State, mxcsr));
1893 }
1894
1895 static void gen_VAESIMC(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1896 {
1897     assert(!s->vex_l);
1898     gen_helper_aesimc_xmm(tcg_env, OP_PTR0, OP_PTR2);
1899 }
1900
1901 /*
1902  * 00 = v*ps Vps, Hps, Wpd
1903  * 66 = v*pd Vpd, Hpd, Wps
1904  * f3 = v*ss Vss, Hss, Wps
1905  * f2 = v*sd Vsd, Hsd, Wps
1906  */
1907 #define SSE_CMP(x) { \
1908     gen_helper_ ## x ## ps ## _xmm, gen_helper_ ## x ## pd ## _xmm, \
1909     gen_helper_ ## x ## ss, gen_helper_ ## x ## sd, \
1910     gen_helper_ ## x ## ps ## _ymm, gen_helper_ ## x ## pd ## _ymm}
1911 static const SSEFunc_0_eppp gen_helper_cmp_funcs[32][6] = {
1912     SSE_CMP(cmpeq),
1913     SSE_CMP(cmplt),
1914     SSE_CMP(cmple),
1915     SSE_CMP(cmpunord),
1916     SSE_CMP(cmpneq),
1917     SSE_CMP(cmpnlt),
1918     SSE_CMP(cmpnle),
1919     SSE_CMP(cmpord),
1920
1921     SSE_CMP(cmpequ),
1922     SSE_CMP(cmpnge),
1923     SSE_CMP(cmpngt),
1924     SSE_CMP(cmpfalse),
1925     SSE_CMP(cmpnequ),
1926     SSE_CMP(cmpge),
1927     SSE_CMP(cmpgt),
1928     SSE_CMP(cmptrue),
1929
1930     SSE_CMP(cmpeqs),
1931     SSE_CMP(cmpltq),
1932     SSE_CMP(cmpleq),
1933     SSE_CMP(cmpunords),
1934     SSE_CMP(cmpneqq),
1935     SSE_CMP(cmpnltq),
1936     SSE_CMP(cmpnleq),
1937     SSE_CMP(cmpords),
1938
1939     SSE_CMP(cmpequs),
1940     SSE_CMP(cmpngeq),
1941     SSE_CMP(cmpngtq),
1942     SSE_CMP(cmpfalses),
1943     SSE_CMP(cmpnequs),
1944     SSE_CMP(cmpgeq),
1945     SSE_CMP(cmpgtq),
1946     SSE_CMP(cmptrues),
1947 };
1948 #undef SSE_CMP
1949
1950 static void gen_VCMP(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1951 {
1952     int index = decode->immediate & (s->prefix & PREFIX_VEX ? 31 : 7);
1953     int b =
1954         s->prefix & PREFIX_REPZ  ? 2 /* ss */ :
1955         s->prefix & PREFIX_REPNZ ? 3 /* sd */ :
1956         !!(s->prefix & PREFIX_DATA) /* pd */ + (s->vex_l << 2);
1957
1958     gen_helper_cmp_funcs[index][b](tcg_env, OP_PTR0, OP_PTR1, OP_PTR2);
1959 }
1960
1961 static void gen_VCOMI(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1962 {
1963     SSEFunc_0_epp fn;
1964     fn = s->prefix & PREFIX_DATA ? gen_helper_comisd : gen_helper_comiss;
1965     fn(tcg_env, OP_PTR1, OP_PTR2);
1966     set_cc_op(s, CC_OP_EFLAGS);
1967 }
1968
1969 static void gen_VCVTPD2PS(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1970 {
1971     if (s->vex_l) {
1972         gen_helper_cvtpd2ps_ymm(tcg_env, OP_PTR0, OP_PTR2);
1973     } else {
1974         gen_helper_cvtpd2ps_xmm(tcg_env, OP_PTR0, OP_PTR2);
1975     }
1976 }
1977
1978 static void gen_VCVTPS2PD(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1979 {
1980     if (s->vex_l) {
1981         gen_helper_cvtps2pd_ymm(tcg_env, OP_PTR0, OP_PTR2);
1982     } else {
1983         gen_helper_cvtps2pd_xmm(tcg_env, OP_PTR0, OP_PTR2);
1984     }
1985 }
1986
1987 static void gen_VCVTPS2PH(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
1988 {
1989     gen_unary_imm_fp_sse(s, env, decode,
1990                       gen_helper_cvtps2ph_xmm,
1991                       gen_helper_cvtps2ph_ymm);
1992     /*
1993      * VCVTPS2PH is the only instruction that performs an operation on a
1994      * register source and then *stores* into memory.
1995      */
1996     if (decode->op[0].has_ea) {
1997         gen_store_sse(s, decode, decode->op[0].offset);
1998     }
1999 }
2000
2001 static void gen_VCVTSD2SS(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2002 {
2003     gen_helper_cvtsd2ss(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2);
2004 }
2005
2006 static void gen_VCVTSS2SD(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2007 {
2008     gen_helper_cvtss2sd(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2);
2009 }
2010
2011 static void gen_VCVTSI2Sx(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2012 {
2013     int vec_len = vector_len(s, decode);
2014     TCGv_i32 in;
2015
2016     tcg_gen_gvec_mov(MO_64, decode->op[0].offset, decode->op[1].offset, vec_len, vec_len);
2017
2018 #ifdef TARGET_X86_64
2019     MemOp ot = decode->op[2].ot;
2020     if (ot == MO_64) {
2021         if (s->prefix & PREFIX_REPNZ) {
2022             gen_helper_cvtsq2sd(tcg_env, OP_PTR0, s->T1);
2023         } else {
2024             gen_helper_cvtsq2ss(tcg_env, OP_PTR0, s->T1);
2025         }
2026         return;
2027     }
2028     in = s->tmp2_i32;
2029     tcg_gen_trunc_tl_i32(in, s->T1);
2030 #else
2031     in = s->T1;
2032 #endif
2033
2034     if (s->prefix & PREFIX_REPNZ) {
2035         gen_helper_cvtsi2sd(tcg_env, OP_PTR0, in);
2036     } else {
2037         gen_helper_cvtsi2ss(tcg_env, OP_PTR0, in);
2038     }
2039 }
2040
2041 static inline void gen_VCVTtSx2SI(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
2042                                   SSEFunc_i_ep ss2si, SSEFunc_l_ep ss2sq,
2043                                   SSEFunc_i_ep sd2si, SSEFunc_l_ep sd2sq)
2044 {
2045     TCGv_i32 out;
2046
2047 #ifdef TARGET_X86_64
2048     MemOp ot = decode->op[0].ot;
2049     if (ot == MO_64) {
2050         if (s->prefix & PREFIX_REPNZ) {
2051             sd2sq(s->T0, tcg_env, OP_PTR2);
2052         } else {
2053             ss2sq(s->T0, tcg_env, OP_PTR2);
2054         }
2055         return;
2056     }
2057
2058     out = s->tmp2_i32;
2059 #else
2060     out = s->T0;
2061 #endif
2062     if (s->prefix & PREFIX_REPNZ) {
2063         sd2si(out, tcg_env, OP_PTR2);
2064     } else {
2065         ss2si(out, tcg_env, OP_PTR2);
2066     }
2067 #ifdef TARGET_X86_64
2068     tcg_gen_extu_i32_tl(s->T0, out);
2069 #endif
2070 }
2071
2072 #ifndef TARGET_X86_64
2073 #define gen_helper_cvtss2sq NULL
2074 #define gen_helper_cvtsd2sq NULL
2075 #define gen_helper_cvttss2sq NULL
2076 #define gen_helper_cvttsd2sq NULL
2077 #endif
2078
2079 static void gen_VCVTSx2SI(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2080 {
2081     gen_VCVTtSx2SI(s, env, decode,
2082                    gen_helper_cvtss2si, gen_helper_cvtss2sq,
2083                    gen_helper_cvtsd2si, gen_helper_cvtsd2sq);
2084 }
2085
2086 static void gen_VCVTTSx2SI(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2087 {
2088     gen_VCVTtSx2SI(s, env, decode,
2089                    gen_helper_cvttss2si, gen_helper_cvttss2sq,
2090                    gen_helper_cvttsd2si, gen_helper_cvttsd2sq);
2091 }
2092
2093 static void gen_VEXTRACTx128(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2094 {
2095     int mask = decode->immediate & 1;
2096     int src_ofs = vector_elem_offset(&decode->op[1], MO_128, mask);
2097     if (decode->op[0].has_ea) {
2098         /* VEX-only instruction, no alignment requirements.  */
2099         gen_sto_env_A0(s, src_ofs, false);
2100     } else {
2101         tcg_gen_gvec_mov(MO_64, decode->op[0].offset, src_ofs, 16, 16);
2102     }
2103 }
2104
2105 static void gen_VEXTRACTPS(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2106 {
2107     gen_pextr(s, env, decode, MO_32);
2108 }
2109
2110 static void gen_vinsertps(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2111 {
2112     int val = decode->immediate;
2113     int dest_word = (val >> 4) & 3;
2114     int new_mask = (val & 15) | (1 << dest_word);
2115     int vec_len = 16;
2116
2117     assert(!s->vex_l);
2118
2119     if (new_mask == 15) {
2120         /* All zeroes except possibly for the inserted element */
2121         tcg_gen_gvec_dup_imm(MO_64, decode->op[0].offset, vec_len, vec_len, 0);
2122     } else if (decode->op[1].offset != decode->op[0].offset) {
2123         gen_store_sse(s, decode, decode->op[1].offset);
2124     }
2125
2126     if (new_mask != (val & 15)) {
2127         tcg_gen_st_i32(s->tmp2_i32, tcg_env,
2128                        vector_elem_offset(&decode->op[0], MO_32, dest_word));
2129     }
2130
2131     if (new_mask != 15) {
2132         TCGv_i32 zero = tcg_constant_i32(0); /* float32_zero */
2133         int i;
2134         for (i = 0; i < 4; i++) {
2135             if ((val >> i) & 1) {
2136                 tcg_gen_st_i32(zero, tcg_env,
2137                                vector_elem_offset(&decode->op[0], MO_32, i));
2138             }
2139         }
2140     }
2141 }
2142
2143 static void gen_VINSERTPS_r(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2144 {
2145     int val = decode->immediate;
2146     tcg_gen_ld_i32(s->tmp2_i32, tcg_env,
2147                    vector_elem_offset(&decode->op[2], MO_32, (val >> 6) & 3));
2148     gen_vinsertps(s, env, decode);
2149 }
2150
2151 static void gen_VINSERTPS_m(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2152 {
2153     tcg_gen_qemu_ld_i32(s->tmp2_i32, s->A0, s->mem_index, MO_LEUL);
2154     gen_vinsertps(s, env, decode);
2155 }
2156
2157 static void gen_VINSERTx128(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2158 {
2159     int mask = decode->immediate & 1;
2160     tcg_gen_gvec_mov(MO_64,
2161                      decode->op[0].offset + offsetof(YMMReg, YMM_X(mask)),
2162                      decode->op[2].offset + offsetof(YMMReg, YMM_X(0)), 16, 16);
2163     tcg_gen_gvec_mov(MO_64,
2164                      decode->op[0].offset + offsetof(YMMReg, YMM_X(!mask)),
2165                      decode->op[1].offset + offsetof(YMMReg, YMM_X(!mask)), 16, 16);
2166 }
2167
2168 static inline void gen_maskmov(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode,
2169                                SSEFunc_0_eppt xmm, SSEFunc_0_eppt ymm)
2170 {
2171     if (!s->vex_l) {
2172         xmm(tcg_env, OP_PTR2, OP_PTR1, s->A0);
2173     } else {
2174         ymm(tcg_env, OP_PTR2, OP_PTR1, s->A0);
2175     }
2176 }
2177
2178 static void gen_VMASKMOVPD_st(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2179 {
2180     gen_maskmov(s, env, decode, gen_helper_vpmaskmovq_st_xmm, gen_helper_vpmaskmovq_st_ymm);
2181 }
2182
2183 static void gen_VMASKMOVPS_st(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2184 {
2185     gen_maskmov(s, env, decode, gen_helper_vpmaskmovd_st_xmm, gen_helper_vpmaskmovd_st_ymm);
2186 }
2187
2188 static void gen_VMOVHPx_ld(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2189 {
2190     gen_ldq_env_A0(s, decode->op[0].offset + offsetof(XMMReg, XMM_Q(1)));
2191     if (decode->op[0].offset != decode->op[1].offset) {
2192         tcg_gen_ld_i64(s->tmp1_i64, tcg_env, decode->op[1].offset + offsetof(XMMReg, XMM_Q(0)));
2193         tcg_gen_st_i64(s->tmp1_i64, tcg_env, decode->op[0].offset + offsetof(XMMReg, XMM_Q(0)));
2194     }
2195 }
2196
2197 static void gen_VMOVHPx_st(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2198 {
2199     gen_stq_env_A0(s, decode->op[2].offset + offsetof(XMMReg, XMM_Q(1)));
2200 }
2201
2202 static void gen_VMOVHPx(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2203 {
2204     if (decode->op[0].offset != decode->op[2].offset) {
2205         tcg_gen_ld_i64(s->tmp1_i64, tcg_env, decode->op[2].offset + offsetof(XMMReg, XMM_Q(1)));
2206         tcg_gen_st_i64(s->tmp1_i64, tcg_env, decode->op[0].offset + offsetof(XMMReg, XMM_Q(1)));
2207     }
2208     if (decode->op[0].offset != decode->op[1].offset) {
2209         tcg_gen_ld_i64(s->tmp1_i64, tcg_env, decode->op[1].offset + offsetof(XMMReg, XMM_Q(0)));
2210         tcg_gen_st_i64(s->tmp1_i64, tcg_env, decode->op[0].offset + offsetof(XMMReg, XMM_Q(0)));
2211     }
2212 }
2213
2214 static void gen_VMOVHLPS(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2215 {
2216     tcg_gen_ld_i64(s->tmp1_i64, tcg_env, decode->op[2].offset + offsetof(XMMReg, XMM_Q(1)));
2217     tcg_gen_st_i64(s->tmp1_i64, tcg_env, decode->op[0].offset + offsetof(XMMReg, XMM_Q(0)));
2218     if (decode->op[0].offset != decode->op[1].offset) {
2219         tcg_gen_ld_i64(s->tmp1_i64, tcg_env, decode->op[1].offset + offsetof(XMMReg, XMM_Q(1)));
2220         tcg_gen_st_i64(s->tmp1_i64, tcg_env, decode->op[0].offset + offsetof(XMMReg, XMM_Q(1)));
2221     }
2222 }
2223
2224 static void gen_VMOVLHPS(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2225 {
2226     tcg_gen_ld_i64(s->tmp1_i64, tcg_env, decode->op[2].offset);
2227     tcg_gen_st_i64(s->tmp1_i64, tcg_env, decode->op[0].offset + offsetof(XMMReg, XMM_Q(1)));
2228     if (decode->op[0].offset != decode->op[1].offset) {
2229         tcg_gen_ld_i64(s->tmp1_i64, tcg_env, decode->op[1].offset + offsetof(XMMReg, XMM_Q(0)));
2230         tcg_gen_st_i64(s->tmp1_i64, tcg_env, decode->op[0].offset + offsetof(XMMReg, XMM_Q(0)));
2231     }
2232 }
2233
2234 /*
2235  * Note that MOVLPx supports 256-bit operation unlike MOVHLPx, MOVLHPx, MOXHPx.
2236  * Use a gvec move to move everything above the bottom 64 bits.
2237  */
2238
2239 static void gen_VMOVLPx(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2240 {
2241     int vec_len = vector_len(s, decode);
2242
2243     tcg_gen_ld_i64(s->tmp1_i64, tcg_env, decode->op[2].offset + offsetof(XMMReg, XMM_Q(0)));
2244     tcg_gen_gvec_mov(MO_64, decode->op[0].offset, decode->op[1].offset, vec_len, vec_len);
2245     tcg_gen_st_i64(s->tmp1_i64, tcg_env, decode->op[0].offset + offsetof(XMMReg, XMM_Q(0)));
2246 }
2247
2248 static void gen_VMOVLPx_ld(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2249 {
2250     int vec_len = vector_len(s, decode);
2251
2252     tcg_gen_qemu_ld_i64(s->tmp1_i64, s->A0, s->mem_index, MO_LEUQ);
2253     tcg_gen_gvec_mov(MO_64, decode->op[0].offset, decode->op[1].offset, vec_len, vec_len);
2254     tcg_gen_st_i64(s->tmp1_i64, OP_PTR0, offsetof(ZMMReg, ZMM_Q(0)));
2255 }
2256
2257 static void gen_VMOVLPx_st(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2258 {
2259     tcg_gen_ld_i64(s->tmp1_i64, OP_PTR2, offsetof(ZMMReg, ZMM_Q(0)));
2260     tcg_gen_qemu_st_i64(s->tmp1_i64, s->A0, s->mem_index, MO_LEUQ);
2261 }
2262
2263 static void gen_VMOVSD_ld(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2264 {
2265     TCGv_i64 zero = tcg_constant_i64(0);
2266
2267     tcg_gen_qemu_ld_i64(s->tmp1_i64, s->A0, s->mem_index, MO_LEUQ);
2268     tcg_gen_st_i64(zero, OP_PTR0, offsetof(ZMMReg, ZMM_Q(1)));
2269     tcg_gen_st_i64(s->tmp1_i64, OP_PTR0, offsetof(ZMMReg, ZMM_Q(0)));
2270 }
2271
2272 static void gen_VMOVSS(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2273 {
2274     int vec_len = vector_len(s, decode);
2275
2276     tcg_gen_ld_i32(s->tmp2_i32, OP_PTR2, offsetof(ZMMReg, ZMM_L(0)));
2277     tcg_gen_gvec_mov(MO_64, decode->op[0].offset, decode->op[1].offset, vec_len, vec_len);
2278     tcg_gen_st_i32(s->tmp2_i32, OP_PTR0, offsetof(ZMMReg, ZMM_L(0)));
2279 }
2280
2281 static void gen_VMOVSS_ld(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2282 {
2283     int vec_len = vector_len(s, decode);
2284
2285     tcg_gen_qemu_ld_i32(s->tmp2_i32, s->A0, s->mem_index, MO_LEUL);
2286     tcg_gen_gvec_dup_imm(MO_64, decode->op[0].offset, vec_len, vec_len, 0);
2287     tcg_gen_st_i32(s->tmp2_i32, OP_PTR0, offsetof(ZMMReg, ZMM_L(0)));
2288 }
2289
2290 static void gen_VMOVSS_st(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2291 {
2292     tcg_gen_ld_i32(s->tmp2_i32, OP_PTR2, offsetof(ZMMReg, ZMM_L(0)));
2293     tcg_gen_qemu_st_i32(s->tmp2_i32, s->A0, s->mem_index, MO_LEUL);
2294 }
2295
2296 static void gen_VPMASKMOV_st(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2297 {
2298     if (s->vex_w) {
2299         gen_VMASKMOVPD_st(s, env, decode);
2300     } else {
2301         gen_VMASKMOVPS_st(s, env, decode);
2302     }
2303 }
2304
2305 static void gen_VPERMD(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2306 {
2307     assert(s->vex_l);
2308     gen_helper_vpermd_ymm(OP_PTR0, OP_PTR1, OP_PTR2);
2309 }
2310
2311 static void gen_VPERM2x128(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2312 {
2313     TCGv_i32 imm = tcg_constant8u_i32(decode->immediate);
2314     assert(s->vex_l);
2315     gen_helper_vpermdq_ymm(OP_PTR0, OP_PTR1, OP_PTR2, imm);
2316 }
2317
2318 static void gen_VPHMINPOSUW(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2319 {
2320     assert(!s->vex_l);
2321     gen_helper_phminposuw_xmm(tcg_env, OP_PTR0, OP_PTR2);
2322 }
2323
2324 static void gen_VROUNDSD(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2325 {
2326     TCGv_i32 imm = tcg_constant8u_i32(decode->immediate);
2327     assert(!s->vex_l);
2328     gen_helper_roundsd_xmm(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2, imm);
2329 }
2330
2331 static void gen_VROUNDSS(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2332 {
2333     TCGv_i32 imm = tcg_constant8u_i32(decode->immediate);
2334     assert(!s->vex_l);
2335     gen_helper_roundss_xmm(tcg_env, OP_PTR0, OP_PTR1, OP_PTR2, imm);
2336 }
2337
2338 static void gen_VSHUF(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2339 {
2340     TCGv_i32 imm = tcg_constant_i32(decode->immediate);
2341     SSEFunc_0_pppi ps, pd, fn;
2342     ps = s->vex_l ? gen_helper_shufps_ymm : gen_helper_shufps_xmm;
2343     pd = s->vex_l ? gen_helper_shufpd_ymm : gen_helper_shufpd_xmm;
2344     fn = s->prefix & PREFIX_DATA ? pd : ps;
2345     fn(OP_PTR0, OP_PTR1, OP_PTR2, imm);
2346 }
2347
2348 static void gen_VUCOMI(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2349 {
2350     SSEFunc_0_epp fn;
2351     fn = s->prefix & PREFIX_DATA ? gen_helper_ucomisd : gen_helper_ucomiss;
2352     fn(tcg_env, OP_PTR1, OP_PTR2);
2353     set_cc_op(s, CC_OP_EFLAGS);
2354 }
2355
2356 static void gen_VZEROALL(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2357 {
2358     TCGv_ptr ptr = tcg_temp_new_ptr();
2359
2360     tcg_gen_addi_ptr(ptr, tcg_env, offsetof(CPUX86State, xmm_regs));
2361     gen_helper_memset(ptr, ptr, tcg_constant_i32(0),
2362                       tcg_constant_ptr(CPU_NB_REGS * sizeof(ZMMReg)));
2363 }
2364
2365 static void gen_VZEROUPPER(DisasContext *s, CPUX86State *env, X86DecodedInsn *decode)
2366 {
2367     int i;
2368
2369     for (i = 0; i < CPU_NB_REGS; i++) {
2370         int offset = offsetof(CPUX86State, xmm_regs[i].ZMM_X(1));
2371         tcg_gen_gvec_dup_imm(MO_64, offset, 16, 16, 0);
2372     }
2373 }