target/i386/tcg/emit.c.inc

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