target-i386/translate.c

   1 /*
   2  *  i386 translation
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19 #include <stdarg.h>
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <inttypes.h>
  24 #include <signal.h>
  25
  26 #include "qemu/host-utils.h"
  27 #include "cpu.h"
  28 #include "disas/disas.h"
  29 #include "tcg-op.h"
  30
  31 #include "exec/helper-proto.h"
  32 #include "exec/helper-gen.h"
  33
  34 #define PREFIX_REPZ   0x01
  35 #define PREFIX_REPNZ  0x02
  36 #define PREFIX_LOCK   0x04
  37 #define PREFIX_DATA   0x08
  38 #define PREFIX_ADR    0x10
  39 #define PREFIX_VEX    0x20
  40
  41 #ifdef TARGET_X86_64
  42 #define CODE64(s) ((s)->code64)
  43 #define REX_X(s) ((s)->rex_x)
  44 #define REX_B(s) ((s)->rex_b)
  45 #else
  46 #define CODE64(s) 0
  47 #define REX_X(s) 0
  48 #define REX_B(s) 0
  49 #endif
  50
  51 #ifdef TARGET_X86_64
  52 # define ctztl  ctz64
  53 # define clztl  clz64
  54 #else
  55 # define ctztl  ctz32
  56 # define clztl  clz32
  57 #endif
  58
  59 //#define MACRO_TEST   1
  60
  61 /* global register indexes */
  62 static TCGv_ptr cpu_env;
  63 static TCGv cpu_A0;
  64 static TCGv cpu_cc_dst, cpu_cc_src, cpu_cc_src2, cpu_cc_srcT;
  65 static TCGv_i32 cpu_cc_op;
  66 static TCGv cpu_regs[CPU_NB_REGS];
  67 /* local temps */
  68 static TCGv cpu_T[2];
  69 /* local register indexes (only used inside old micro ops) */
  70 static TCGv cpu_tmp0, cpu_tmp4;
  71 static TCGv_ptr cpu_ptr0, cpu_ptr1;
  72 static TCGv_i32 cpu_tmp2_i32, cpu_tmp3_i32;
  73 static TCGv_i64 cpu_tmp1_i64;
  74
  75 static uint8_t gen_opc_cc_op[OPC_BUF_SIZE];
  76
  77 #include "exec/gen-icount.h"
  78
  79 #ifdef TARGET_X86_64
  80 static int x86_64_hregs;
  81 #endif
  82
  83 typedef struct DisasContext {
  84     /* current insn context */
  85     int override; /* -1 if no override */
  86     int prefix;
  87     TCGMemOp aflag;
  88     TCGMemOp dflag;
  89     target_ulong pc; /* pc = eip + cs_base */
  90     int is_jmp; /* 1 = means jump (stop translation), 2 means CPU
  91                    static state change (stop translation) */
  92     /* current block context */
  93     target_ulong cs_base; /* base of CS segment */
  94     int pe;     /* protected mode */
  95     int code32; /* 32 bit code segment */
  96 #ifdef TARGET_X86_64
  97     int lma;    /* long mode active */
  98     int code64; /* 64 bit code segment */
  99     int rex_x, rex_b;
 100 #endif
 101     int vex_l;  /* vex vector length */
 102     int vex_v;  /* vex vvvv register, without 1's compliment.  */
 103     int ss32;   /* 32 bit stack segment */
 104     CCOp cc_op;  /* current CC operation */
 105     bool cc_op_dirty;
 106     int addseg; /* non zero if either DS/ES/SS have a non zero base */
 107     int f_st;   /* currently unused */
 108     int vm86;   /* vm86 mode */
 109     int cpl;
 110     int iopl;
 111     int tf;     /* TF cpu flag */
 112     int singlestep_enabled; /* "hardware" single step enabled */
 113     int jmp_opt; /* use direct block chaining for direct jumps */
 114     int mem_index; /* select memory access functions */
 115     uint64_t flags; /* all execution flags */
 116     struct TranslationBlock *tb;
 117     int popl_esp_hack; /* for correct popl with esp base handling */
 118     int rip_offset; /* only used in x86_64, but left for simplicity */
 119     int cpuid_features;
 120     int cpuid_ext_features;
 121     int cpuid_ext2_features;
 122     int cpuid_ext3_features;
 123     int cpuid_7_0_ebx_features;
 124 } DisasContext;
 125
 126 static void gen_eob(DisasContext *s);
 127 static void gen_jmp(DisasContext *s, target_ulong eip);
 128 static void gen_jmp_tb(DisasContext *s, target_ulong eip, int tb_num);
 129 static void gen_op(DisasContext *s1, int op, TCGMemOp ot, int d);
 130
 131 /* i386 arith/logic operations */
 132 enum {
 133     OP_ADDL,
 134     OP_ORL,
 135     OP_ADCL,
 136     OP_SBBL,
 137     OP_ANDL,
 138     OP_SUBL,
 139     OP_XORL,
 140     OP_CMPL,
 141 };
 142
 143 /* i386 shift ops */
 144 enum {
 145     OP_ROL,
 146     OP_ROR,
 147     OP_RCL,
 148     OP_RCR,
 149     OP_SHL,
 150     OP_SHR,
 151     OP_SHL1, /* undocumented */
 152     OP_SAR = 7,
 153 };
 154
 155 enum {
 156     JCC_O,
 157     JCC_B,
 158     JCC_Z,
 159     JCC_BE,
 160     JCC_S,
 161     JCC_P,
 162     JCC_L,
 163     JCC_LE,
 164 };
 165
 166 enum {
 167     /* I386 int registers */
 168     OR_EAX,   /* MUST be even numbered */
 169     OR_ECX,
 170     OR_EDX,
 171     OR_EBX,
 172     OR_ESP,
 173     OR_EBP,
 174     OR_ESI,
 175     OR_EDI,
 176
 177     OR_TMP0 = 16,    /* temporary operand register */
 178     OR_TMP1,
 179     OR_A0, /* temporary register used when doing address evaluation */
 180 };
 181
 182 enum {
 183     USES_CC_DST  = 1,
 184     USES_CC_SRC  = 2,
 185     USES_CC_SRC2 = 4,
 186     USES_CC_SRCT = 8,
 187 };
 188
 189 /* Bit set if the global variable is live after setting CC_OP to X.  */
 190 static const uint8_t cc_op_live[CC_OP_NB] = {
 191     [CC_OP_DYNAMIC] = USES_CC_DST | USES_CC_SRC | USES_CC_SRC2,
 192     [CC_OP_EFLAGS] = USES_CC_SRC,
 193     [CC_OP_MULB ... CC_OP_MULQ] = USES_CC_DST | USES_CC_SRC,
 194     [CC_OP_ADDB ... CC_OP_ADDQ] = USES_CC_DST | USES_CC_SRC,
 195     [CC_OP_ADCB ... CC_OP_ADCQ] = USES_CC_DST | USES_CC_SRC | USES_CC_SRC2,
 196     [CC_OP_SUBB ... CC_OP_SUBQ] = USES_CC_DST | USES_CC_SRC | USES_CC_SRCT,
 197     [CC_OP_SBBB ... CC_OP_SBBQ] = USES_CC_DST | USES_CC_SRC | USES_CC_SRC2,
 198     [CC_OP_LOGICB ... CC_OP_LOGICQ] = USES_CC_DST,
 199     [CC_OP_INCB ... CC_OP_INCQ] = USES_CC_DST | USES_CC_SRC,
 200     [CC_OP_DECB ... CC_OP_DECQ] = USES_CC_DST | USES_CC_SRC,
 201     [CC_OP_SHLB ... CC_OP_SHLQ] = USES_CC_DST | USES_CC_SRC,
 202     [CC_OP_SARB ... CC_OP_SARQ] = USES_CC_DST | USES_CC_SRC,
 203     [CC_OP_BMILGB ... CC_OP_BMILGQ] = USES_CC_DST | USES_CC_SRC,
 204     [CC_OP_ADCX] = USES_CC_DST | USES_CC_SRC,
 205     [CC_OP_ADOX] = USES_CC_SRC | USES_CC_SRC2,
 206     [CC_OP_ADCOX] = USES_CC_DST | USES_CC_SRC | USES_CC_SRC2,
 207     [CC_OP_CLR] = 0,
 208 };
 209
 210 static void set_cc_op(DisasContext *s, CCOp op)
 211 {
 212     int dead;
 213
 214     if (s->cc_op == op) {
 215         return;
 216     }
 217
 218     /* Discard CC computation that will no longer be used.  */
 219     dead = cc_op_live[s->cc_op] & ~cc_op_live[op];
 220     if (dead & USES_CC_DST) {
 221         tcg_gen_discard_tl(cpu_cc_dst);
 222     }
 223     if (dead & USES_CC_SRC) {
 224         tcg_gen_discard_tl(cpu_cc_src);
 225     }
 226     if (dead & USES_CC_SRC2) {
 227         tcg_gen_discard_tl(cpu_cc_src2);
 228     }
 229     if (dead & USES_CC_SRCT) {
 230         tcg_gen_discard_tl(cpu_cc_srcT);
 231     }
 232
 233     if (op == CC_OP_DYNAMIC) {
 234         /* The DYNAMIC setting is translator only, and should never be
 235            stored.  Thus we always consider it clean.  */
 236         s->cc_op_dirty = false;
 237     } else {
 238         /* Discard any computed CC_OP value (see shifts).  */
 239         if (s->cc_op == CC_OP_DYNAMIC) {
 240             tcg_gen_discard_i32(cpu_cc_op);
 241         }
 242         s->cc_op_dirty = true;
 243     }
 244     s->cc_op = op;
 245 }
 246
 247 static void gen_update_cc_op(DisasContext *s)
 248 {
 249     if (s->cc_op_dirty) {
 250         tcg_gen_movi_i32(cpu_cc_op, s->cc_op);
 251         s->cc_op_dirty = false;
 252     }
 253 }
 254
 255 #ifdef TARGET_X86_64
 256
 257 #define NB_OP_SIZES 4
 258
 259 #else /* !TARGET_X86_64 */
 260
 261 #define NB_OP_SIZES 3
 262
 263 #endif /* !TARGET_X86_64 */
 264
 265 #if defined(HOST_WORDS_BIGENDIAN)
 266 #define REG_B_OFFSET (sizeof(target_ulong) - 1)
 267 #define REG_H_OFFSET (sizeof(target_ulong) - 2)
 268 #define REG_W_OFFSET (sizeof(target_ulong) - 2)
 269 #define REG_L_OFFSET (sizeof(target_ulong) - 4)
 270 #define REG_LH_OFFSET (sizeof(target_ulong) - 8)
 271 #else
 272 #define REG_B_OFFSET 0
 273 #define REG_H_OFFSET 1
 274 #define REG_W_OFFSET 0
 275 #define REG_L_OFFSET 0
 276 #define REG_LH_OFFSET 4
 277 #endif
 278
 279 /* In instruction encodings for byte register accesses the
 280  * register number usually indicates "low 8 bits of register N";
 281  * however there are some special cases where N 4..7 indicates
 282  * [AH, CH, DH, BH], ie "bits 15..8 of register N-4". Return
 283  * true for this special case, false otherwise.
 284  */
 285 static inline bool byte_reg_is_xH(int reg)
 286 {
 287     if (reg < 4) {
 288         return false;
 289     }
 290 #ifdef TARGET_X86_64
 291     if (reg >= 8 || x86_64_hregs) {
 292         return false;
 293     }
 294 #endif
 295     return true;
 296 }
 297
 298 /* Select the size of a push/pop operation.  */
 299 static inline TCGMemOp mo_pushpop(DisasContext *s, TCGMemOp ot)
 300 {
 301     if (CODE64(s)) {
 302         return ot == MO_16 ? MO_16 : MO_64;
 303     } else {
 304         return ot;
 305     }
 306 }
 307
 308 /* Select only size 64 else 32.  Used for SSE operand sizes.  */
 309 static inline TCGMemOp mo_64_32(TCGMemOp ot)
 310 {
 311 #ifdef TARGET_X86_64
 312     return ot == MO_64 ? MO_64 : MO_32;
 313 #else
 314     return MO_32;
 315 #endif
 316 }
 317
 318 /* Select size 8 if lsb of B is clear, else OT.  Used for decoding
 319    byte vs word opcodes.  */
 320 static inline TCGMemOp mo_b_d(int b, TCGMemOp ot)
 321 {
 322     return b & 1 ? ot : MO_8;
 323 }
 324
 325 /* Select size 8 if lsb of B is clear, else OT capped at 32.
 326    Used for decoding operand size of port opcodes.  */
 327 static inline TCGMemOp mo_b_d32(int b, TCGMemOp ot)
 328 {
 329     return b & 1 ? (ot == MO_16 ? MO_16 : MO_32) : MO_8;
 330 }
 331
 332 static void gen_op_mov_reg_v(TCGMemOp ot, int reg, TCGv t0)
 333 {
 334     switch(ot) {
 335     case MO_8:
 336         if (!byte_reg_is_xH(reg)) {
 337             tcg_gen_deposit_tl(cpu_regs[reg], cpu_regs[reg], t0, 0, 8);
 338         } else {
 339             tcg_gen_deposit_tl(cpu_regs[reg - 4], cpu_regs[reg - 4], t0, 8, 8);
 340         }
 341         break;
 342     case MO_16:
 343         tcg_gen_deposit_tl(cpu_regs[reg], cpu_regs[reg], t0, 0, 16);
 344         break;
 345     case MO_32:
 346         /* For x86_64, this sets the higher half of register to zero.
 347            For i386, this is equivalent to a mov. */
 348         tcg_gen_ext32u_tl(cpu_regs[reg], t0);
 349         break;
 350 #ifdef TARGET_X86_64
 351     case MO_64:
 352         tcg_gen_mov_tl(cpu_regs[reg], t0);
 353         break;
 354 #endif
 355     default:
 356         tcg_abort();
 357     }
 358 }
 359
 360 static inline void gen_op_mov_v_reg(TCGMemOp ot, TCGv t0, int reg)
 361 {
 362     if (ot == MO_8 && byte_reg_is_xH(reg)) {
 363         tcg_gen_shri_tl(t0, cpu_regs[reg - 4], 8);
 364         tcg_gen_ext8u_tl(t0, t0);
 365     } else {
 366         tcg_gen_mov_tl(t0, cpu_regs[reg]);
 367     }
 368 }
 369
 370 static inline void gen_op_movl_A0_reg(int reg)
 371 {
 372     tcg_gen_mov_tl(cpu_A0, cpu_regs[reg]);
 373 }
 374
 375 static inline void gen_op_addl_A0_im(int32_t val)
 376 {
 377     tcg_gen_addi_tl(cpu_A0, cpu_A0, val);
 378 #ifdef TARGET_X86_64
 379     tcg_gen_andi_tl(cpu_A0, cpu_A0, 0xffffffff);
 380 #endif
 381 }
 382
 383 #ifdef TARGET_X86_64
 384 static inline void gen_op_addq_A0_im(int64_t val)
 385 {
 386     tcg_gen_addi_tl(cpu_A0, cpu_A0, val);
 387 }
 388 #endif
 389
 390 static void gen_add_A0_im(DisasContext *s, int val)
 391 {
 392 #ifdef TARGET_X86_64
 393     if (CODE64(s))
 394         gen_op_addq_A0_im(val);
 395     else
 396 #endif
 397         gen_op_addl_A0_im(val);
 398 }
 399
 400 static inline void gen_op_jmp_v(TCGv dest)
 401 {
 402     tcg_gen_st_tl(dest, cpu_env, offsetof(CPUX86State, eip));
 403 }
 404
 405 static inline void gen_op_add_reg_im(TCGMemOp size, int reg, int32_t val)
 406 {
 407     tcg_gen_addi_tl(cpu_tmp0, cpu_regs[reg], val);
 408     gen_op_mov_reg_v(size, reg, cpu_tmp0);
 409 }
 410
 411 static inline void gen_op_add_reg_T0(TCGMemOp size, int reg)
 412 {
 413     tcg_gen_add_tl(cpu_tmp0, cpu_regs[reg], cpu_T[0]);
 414     gen_op_mov_reg_v(size, reg, cpu_tmp0);
 415 }
 416
 417 static inline void gen_op_addl_A0_reg_sN(int shift, int reg)
 418 {
 419     tcg_gen_mov_tl(cpu_tmp0, cpu_regs[reg]);
 420     if (shift != 0)
 421         tcg_gen_shli_tl(cpu_tmp0, cpu_tmp0, shift);
 422     tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
 423     /* For x86_64, this sets the higher half of register to zero.
 424        For i386, this is equivalent to a nop. */
 425     tcg_gen_ext32u_tl(cpu_A0, cpu_A0);
 426 }
 427
 428 static inline void gen_op_movl_A0_seg(int reg)
 429 {
 430     tcg_gen_ld32u_tl(cpu_A0, cpu_env, offsetof(CPUX86State, segs[reg].base) + REG_L_OFFSET);
 431 }
 432
 433 static inline void gen_op_addl_A0_seg(DisasContext *s, int reg)
 434 {
 435     tcg_gen_ld_tl(cpu_tmp0, cpu_env, offsetof(CPUX86State, segs[reg].base));
 436 #ifdef TARGET_X86_64
 437     if (CODE64(s)) {
 438         tcg_gen_andi_tl(cpu_A0, cpu_A0, 0xffffffff);
 439         tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
 440     } else {
 441         tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
 442         tcg_gen_andi_tl(cpu_A0, cpu_A0, 0xffffffff);
 443     }
 444 #else
 445     tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
 446 #endif
 447 }
 448
 449 #ifdef TARGET_X86_64
 450 static inline void gen_op_movq_A0_seg(int reg)
 451 {
 452     tcg_gen_ld_tl(cpu_A0, cpu_env, offsetof(CPUX86State, segs[reg].base));
 453 }
 454
 455 static inline void gen_op_addq_A0_seg(int reg)
 456 {
 457     tcg_gen_ld_tl(cpu_tmp0, cpu_env, offsetof(CPUX86State, segs[reg].base));
 458     tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
 459 }
 460
 461 static inline void gen_op_movq_A0_reg(int reg)
 462 {
 463     tcg_gen_mov_tl(cpu_A0, cpu_regs[reg]);
 464 }
 465
 466 static inline void gen_op_addq_A0_reg_sN(int shift, int reg)
 467 {
 468     tcg_gen_mov_tl(cpu_tmp0, cpu_regs[reg]);
 469     if (shift != 0)
 470         tcg_gen_shli_tl(cpu_tmp0, cpu_tmp0, shift);
 471     tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
 472 }
 473 #endif
 474
 475 static inline void gen_op_ld_v(DisasContext *s, int idx, TCGv t0, TCGv a0)
 476 {
 477     tcg_gen_qemu_ld_tl(t0, a0, s->mem_index, idx | MO_LE);
 478 }
 479
 480 static inline void gen_op_st_v(DisasContext *s, int idx, TCGv t0, TCGv a0)
 481 {
 482     tcg_gen_qemu_st_tl(t0, a0, s->mem_index, idx | MO_LE);
 483 }
 484
 485 static inline void gen_op_st_rm_T0_A0(DisasContext *s, int idx, int d)
 486 {
 487     if (d == OR_TMP0) {
 488         gen_op_st_v(s, idx, cpu_T[0], cpu_A0);
 489     } else {
 490         gen_op_mov_reg_v(idx, d, cpu_T[0]);
 491     }
 492 }
 493
 494 static inline void gen_jmp_im(target_ulong pc)
 495 {
 496     tcg_gen_movi_tl(cpu_tmp0, pc);
 497     gen_op_jmp_v(cpu_tmp0);
 498 }
 499
 500 static inline void gen_string_movl_A0_ESI(DisasContext *s)
 501 {
 502     int override;
 503
 504     override = s->override;
 505     switch (s->aflag) {
 506 #ifdef TARGET_X86_64
 507     case MO_64:
 508         if (override >= 0) {
 509             gen_op_movq_A0_seg(override);
 510             gen_op_addq_A0_reg_sN(0, R_ESI);
 511         } else {
 512             gen_op_movq_A0_reg(R_ESI);
 513         }
 514         break;
 515 #endif
 516     case MO_32:
 517         /* 32 bit address */
 518         if (s->addseg && override < 0)
 519             override = R_DS;
 520         if (override >= 0) {
 521             gen_op_movl_A0_seg(override);
 522             gen_op_addl_A0_reg_sN(0, R_ESI);
 523         } else {
 524             gen_op_movl_A0_reg(R_ESI);
 525         }
 526         break;
 527     case MO_16:
 528         /* 16 address, always override */
 529         if (override < 0)
 530             override = R_DS;
 531         tcg_gen_ext16u_tl(cpu_A0, cpu_regs[R_ESI]);
 532         gen_op_addl_A0_seg(s, override);
 533         break;
 534     default:
 535         tcg_abort();
 536     }
 537 }
 538
 539 static inline void gen_string_movl_A0_EDI(DisasContext *s)
 540 {
 541     switch (s->aflag) {
 542 #ifdef TARGET_X86_64
 543     case MO_64:
 544         gen_op_movq_A0_reg(R_EDI);
 545         break;
 546 #endif
 547     case MO_32:
 548         if (s->addseg) {
 549             gen_op_movl_A0_seg(R_ES);
 550             gen_op_addl_A0_reg_sN(0, R_EDI);
 551         } else {
 552             gen_op_movl_A0_reg(R_EDI);
 553         }
 554         break;
 555     case MO_16:
 556         tcg_gen_ext16u_tl(cpu_A0, cpu_regs[R_EDI]);
 557         gen_op_addl_A0_seg(s, R_ES);
 558         break;
 559     default:
 560         tcg_abort();
 561     }
 562 }
 563
 564 static inline void gen_op_movl_T0_Dshift(TCGMemOp ot)
 565 {
 566     tcg_gen_ld32s_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, df));
 567     tcg_gen_shli_tl(cpu_T[0], cpu_T[0], ot);
 568 };
 569
 570 static TCGv gen_ext_tl(TCGv dst, TCGv src, TCGMemOp size, bool sign)
 571 {
 572     switch (size) {
 573     case MO_8:
 574         if (sign) {
 575             tcg_gen_ext8s_tl(dst, src);
 576         } else {
 577             tcg_gen_ext8u_tl(dst, src);
 578         }
 579         return dst;
 580     case MO_16:
 581         if (sign) {
 582             tcg_gen_ext16s_tl(dst, src);
 583         } else {
 584             tcg_gen_ext16u_tl(dst, src);
 585         }
 586         return dst;
 587 #ifdef TARGET_X86_64
 588     case MO_32:
 589         if (sign) {
 590             tcg_gen_ext32s_tl(dst, src);
 591         } else {
 592             tcg_gen_ext32u_tl(dst, src);
 593         }
 594         return dst;
 595 #endif
 596     default:
 597         return src;
 598     }
 599 }
 600
 601 static void gen_extu(TCGMemOp ot, TCGv reg)
 602 {
 603     gen_ext_tl(reg, reg, ot, false);
 604 }
 605
 606 static void gen_exts(TCGMemOp ot, TCGv reg)
 607 {
 608     gen_ext_tl(reg, reg, ot, true);
 609 }
 610
 611 static inline void gen_op_jnz_ecx(TCGMemOp size, int label1)
 612 {
 613     tcg_gen_mov_tl(cpu_tmp0, cpu_regs[R_ECX]);
 614     gen_extu(size, cpu_tmp0);
 615     tcg_gen_brcondi_tl(TCG_COND_NE, cpu_tmp0, 0, label1);
 616 }
 617
 618 static inline void gen_op_jz_ecx(TCGMemOp size, int label1)
 619 {
 620     tcg_gen_mov_tl(cpu_tmp0, cpu_regs[R_ECX]);
 621     gen_extu(size, cpu_tmp0);
 622     tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, label1);
 623 }
 624
 625 static void gen_helper_in_func(TCGMemOp ot, TCGv v, TCGv_i32 n)
 626 {
 627     switch (ot) {
 628     case MO_8:
 629         gen_helper_inb(v, n);
 630         break;
 631     case MO_16:
 632         gen_helper_inw(v, n);
 633         break;
 634     case MO_32:
 635         gen_helper_inl(v, n);
 636         break;
 637     default:
 638         tcg_abort();
 639     }
 640 }
 641
 642 static void gen_helper_out_func(TCGMemOp ot, TCGv_i32 v, TCGv_i32 n)
 643 {
 644     switch (ot) {
 645     case MO_8:
 646         gen_helper_outb(v, n);
 647         break;
 648     case MO_16:
 649         gen_helper_outw(v, n);
 650         break;
 651     case MO_32:
 652         gen_helper_outl(v, n);
 653         break;
 654     default:
 655         tcg_abort();
 656     }
 657 }
 658
 659 static void gen_check_io(DisasContext *s, TCGMemOp ot, target_ulong cur_eip,
 660                          uint32_t svm_flags)
 661 {
 662     int state_saved;
 663     target_ulong next_eip;
 664
 665     state_saved = 0;
 666     if (s->pe && (s->cpl > s->iopl || s->vm86)) {
 667         gen_update_cc_op(s);
 668         gen_jmp_im(cur_eip);
 669         state_saved = 1;
 670         tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
 671         switch (ot) {
 672         case MO_8:
 673             gen_helper_check_iob(cpu_env, cpu_tmp2_i32);
 674             break;
 675         case MO_16:
 676             gen_helper_check_iow(cpu_env, cpu_tmp2_i32);
 677             break;
 678         case MO_32:
 679             gen_helper_check_iol(cpu_env, cpu_tmp2_i32);
 680             break;
 681         default:
 682             tcg_abort();
 683         }
 684     }
 685     if(s->flags & HF_SVMI_MASK) {
 686         if (!state_saved) {
 687             gen_update_cc_op(s);
 688             gen_jmp_im(cur_eip);
 689         }
 690         svm_flags |= (1 << (4 + ot));
 691         next_eip = s->pc - s->cs_base;
 692         tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
 693         gen_helper_svm_check_io(cpu_env, cpu_tmp2_i32,
 694                                 tcg_const_i32(svm_flags),
 695                                 tcg_const_i32(next_eip - cur_eip));
 696     }
 697 }
 698
 699 static inline void gen_movs(DisasContext *s, TCGMemOp ot)
 700 {
 701     gen_string_movl_A0_ESI(s);
 702     gen_op_ld_v(s, ot, cpu_T[0], cpu_A0);
 703     gen_string_movl_A0_EDI(s);
 704     gen_op_st_v(s, ot, cpu_T[0], cpu_A0);
 705     gen_op_movl_T0_Dshift(ot);
 706     gen_op_add_reg_T0(s->aflag, R_ESI);
 707     gen_op_add_reg_T0(s->aflag, R_EDI);
 708 }
 709
 710 static void gen_op_update1_cc(void)
 711 {
 712     tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
 713 }
 714
 715 static void gen_op_update2_cc(void)
 716 {
 717     tcg_gen_mov_tl(cpu_cc_src, cpu_T[1]);
 718     tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
 719 }
 720
 721 static void gen_op_update3_cc(TCGv reg)
 722 {
 723     tcg_gen_mov_tl(cpu_cc_src2, reg);
 724     tcg_gen_mov_tl(cpu_cc_src, cpu_T[1]);
 725     tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
 726 }
 727
 728 static inline void gen_op_testl_T0_T1_cc(void)
 729 {
 730     tcg_gen_and_tl(cpu_cc_dst, cpu_T[0], cpu_T[1]);
 731 }
 732
 733 static void gen_op_update_neg_cc(void)
 734 {
 735     tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
 736     tcg_gen_neg_tl(cpu_cc_src, cpu_T[0]);
 737     tcg_gen_movi_tl(cpu_cc_srcT, 0);
 738 }
 739
 740 /* compute all eflags to cc_src */
 741 static void gen_compute_eflags(DisasContext *s)
 742 {
 743     TCGv zero, dst, src1, src2;
 744     int live, dead;
 745
 746     if (s->cc_op == CC_OP_EFLAGS) {
 747         return;
 748     }
 749     if (s->cc_op == CC_OP_CLR) {
 750         tcg_gen_movi_tl(cpu_cc_src, CC_Z | CC_P);
 751         set_cc_op(s, CC_OP_EFLAGS);
 752         return;
 753     }
 754
 755     TCGV_UNUSED(zero);
 756     dst = cpu_cc_dst;
 757     src1 = cpu_cc_src;
 758     src2 = cpu_cc_src2;
 759
 760     /* Take care to not read values that are not live.  */
 761     live = cc_op_live[s->cc_op] & ~USES_CC_SRCT;
 762     dead = live ^ (USES_CC_DST | USES_CC_SRC | USES_CC_SRC2);
 763     if (dead) {
 764         zero = tcg_const_tl(0);
 765         if (dead & USES_CC_DST) {
 766             dst = zero;
 767         }
 768         if (dead & USES_CC_SRC) {
 769             src1 = zero;
 770         }
 771         if (dead & USES_CC_SRC2) {
 772             src2 = zero;
 773         }
 774     }
 775
 776     gen_update_cc_op(s);
 777     gen_helper_cc_compute_all(cpu_cc_src, dst, src1, src2, cpu_cc_op);
 778     set_cc_op(s, CC_OP_EFLAGS);
 779
 780     if (dead) {
 781         tcg_temp_free(zero);
 782     }
 783 }
 784
 785 typedef struct CCPrepare {
 786     TCGCond cond;
 787     TCGv reg;
 788     TCGv reg2;
 789     target_ulong imm;
 790     target_ulong mask;
 791     bool use_reg2;
 792     bool no_setcond;
 793 } CCPrepare;
 794
 795 /* compute eflags.C to reg */
 796 static CCPrepare gen_prepare_eflags_c(DisasContext *s, TCGv reg)
 797 {
 798     TCGv t0, t1;
 799     int size, shift;
 800
 801     switch (s->cc_op) {
 802     case CC_OP_SUBB ... CC_OP_SUBQ:
 803         /* (DATA_TYPE)CC_SRCT < (DATA_TYPE)CC_SRC */
 804         size = s->cc_op - CC_OP_SUBB;
 805         t1 = gen_ext_tl(cpu_tmp0, cpu_cc_src, size, false);
 806         /* If no temporary was used, be careful not to alias t1 and t0.  */
 807         t0 = TCGV_EQUAL(t1, cpu_cc_src) ? cpu_tmp0 : reg;
 808         tcg_gen_mov_tl(t0, cpu_cc_srcT);
 809         gen_extu(size, t0);
 810         goto add_sub;
 811
 812     case CC_OP_ADDB ... CC_OP_ADDQ:
 813         /* (DATA_TYPE)CC_DST < (DATA_TYPE)CC_SRC */
 814         size = s->cc_op - CC_OP_ADDB;
 815         t1 = gen_ext_tl(cpu_tmp0, cpu_cc_src, size, false);
 816         t0 = gen_ext_tl(reg, cpu_cc_dst, size, false);
 817     add_sub:
 818         return (CCPrepare) { .cond = TCG_COND_LTU, .reg = t0,
 819                              .reg2 = t1, .mask = -1, .use_reg2 = true };
 820
 821     case CC_OP_LOGICB ... CC_OP_LOGICQ:
 822     case CC_OP_CLR:
 823         return (CCPrepare) { .cond = TCG_COND_NEVER, .mask = -1 };
 824
 825     case CC_OP_INCB ... CC_OP_INCQ:
 826     case CC_OP_DECB ... CC_OP_DECQ:
 827         return (CCPrepare) { .cond = TCG_COND_NE, .reg = cpu_cc_src,
 828                              .mask = -1, .no_setcond = true };
 829
 830     case CC_OP_SHLB ... CC_OP_SHLQ:
 831         /* (CC_SRC >> (DATA_BITS - 1)) & 1 */
 832         size = s->cc_op - CC_OP_SHLB;
 833         shift = (8 << size) - 1;
 834         return (CCPrepare) { .cond = TCG_COND_NE, .reg = cpu_cc_src,
 835                              .mask = (target_ulong)1 << shift };
 836
 837     case CC_OP_MULB ... CC_OP_MULQ:
 838         return (CCPrepare) { .cond = TCG_COND_NE,
 839                              .reg = cpu_cc_src, .mask = -1 };
 840
 841     case CC_OP_BMILGB ... CC_OP_BMILGQ:
 842         size = s->cc_op - CC_OP_BMILGB;
 843         t0 = gen_ext_tl(reg, cpu_cc_src, size, false);
 844         return (CCPrepare) { .cond = TCG_COND_EQ, .reg = t0, .mask = -1 };
 845
 846     case CC_OP_ADCX:
 847     case CC_OP_ADCOX:
 848         return (CCPrepare) { .cond = TCG_COND_NE, .reg = cpu_cc_dst,
 849                              .mask = -1, .no_setcond = true };
 850
 851     case CC_OP_EFLAGS:
 852     case CC_OP_SARB ... CC_OP_SARQ:
 853         /* CC_SRC & 1 */
 854         return (CCPrepare) { .cond = TCG_COND_NE,
 855                              .reg = cpu_cc_src, .mask = CC_C };
 856
 857     default:
 858        /* The need to compute only C from CC_OP_DYNAMIC is important
 859           in efficiently implementing e.g. INC at the start of a TB.  */
 860        gen_update_cc_op(s);
 861        gen_helper_cc_compute_c(reg, cpu_cc_dst, cpu_cc_src,
 862                                cpu_cc_src2, cpu_cc_op);
 863        return (CCPrepare) { .cond = TCG_COND_NE, .reg = reg,
 864                             .mask = -1, .no_setcond = true };
 865     }
 866 }
 867
 868 /* compute eflags.P to reg */
 869 static CCPrepare gen_prepare_eflags_p(DisasContext *s, TCGv reg)
 870 {
 871     gen_compute_eflags(s);
 872     return (CCPrepare) { .cond = TCG_COND_NE, .reg = cpu_cc_src,
 873                          .mask = CC_P };
 874 }
 875
 876 /* compute eflags.S to reg */
 877 static CCPrepare gen_prepare_eflags_s(DisasContext *s, TCGv reg)
 878 {
 879     switch (s->cc_op) {
 880     case CC_OP_DYNAMIC:
 881         gen_compute_eflags(s);
 882         /* FALLTHRU */
 883     case CC_OP_EFLAGS:
 884     case CC_OP_ADCX:
 885     case CC_OP_ADOX:
 886     case CC_OP_ADCOX:
 887         return (CCPrepare) { .cond = TCG_COND_NE, .reg = cpu_cc_src,
 888                              .mask = CC_S };
 889     case CC_OP_CLR:
 890         return (CCPrepare) { .cond = TCG_COND_NEVER, .mask = -1 };
 891     default:
 892         {
 893             TCGMemOp size = (s->cc_op - CC_OP_ADDB) & 3;
 894             TCGv t0 = gen_ext_tl(reg, cpu_cc_dst, size, true);
 895             return (CCPrepare) { .cond = TCG_COND_LT, .reg = t0, .mask = -1 };
 896         }
 897     }
 898 }
 899
 900 /* compute eflags.O to reg */
 901 static CCPrepare gen_prepare_eflags_o(DisasContext *s, TCGv reg)
 902 {
 903     switch (s->cc_op) {
 904     case CC_OP_ADOX:
 905     case CC_OP_ADCOX:
 906         return (CCPrepare) { .cond = TCG_COND_NE, .reg = cpu_cc_src2,
 907                              .mask = -1, .no_setcond = true };
 908     case CC_OP_CLR:
 909         return (CCPrepare) { .cond = TCG_COND_NEVER, .mask = -1 };
 910     default:
 911         gen_compute_eflags(s);
 912         return (CCPrepare) { .cond = TCG_COND_NE, .reg = cpu_cc_src,
 913                              .mask = CC_O };
 914     }
 915 }
 916
 917 /* compute eflags.Z to reg */
 918 static CCPrepare gen_prepare_eflags_z(DisasContext *s, TCGv reg)
 919 {
 920     switch (s->cc_op) {
 921     case CC_OP_DYNAMIC:
 922         gen_compute_eflags(s);
 923         /* FALLTHRU */
 924     case CC_OP_EFLAGS:
 925     case CC_OP_ADCX:
 926     case CC_OP_ADOX:
 927     case CC_OP_ADCOX:
 928         return (CCPrepare) { .cond = TCG_COND_NE, .reg = cpu_cc_src,
 929                              .mask = CC_Z };
 930     case CC_OP_CLR:
 931         return (CCPrepare) { .cond = TCG_COND_ALWAYS, .mask = -1 };
 932     default:
 933         {
 934             TCGMemOp size = (s->cc_op - CC_OP_ADDB) & 3;
 935             TCGv t0 = gen_ext_tl(reg, cpu_cc_dst, size, false);
 936             return (CCPrepare) { .cond = TCG_COND_EQ, .reg = t0, .mask = -1 };
 937         }
 938     }
 939 }
 940
 941 /* perform a conditional store into register 'reg' according to jump opcode
 942    value 'b'. In the fast case, T0 is guaranted not to be used. */
 943 static CCPrepare gen_prepare_cc(DisasContext *s, int b, TCGv reg)
 944 {
 945     int inv, jcc_op, cond;
 946     TCGMemOp size;
 947     CCPrepare cc;
 948     TCGv t0;
 949
 950     inv = b & 1;
 951     jcc_op = (b >> 1) & 7;
 952
 953     switch (s->cc_op) {
 954     case CC_OP_SUBB ... CC_OP_SUBQ:
 955         /* We optimize relational operators for the cmp/jcc case.  */
 956         size = s->cc_op - CC_OP_SUBB;
 957         switch (jcc_op) {
 958         case JCC_BE:
 959             tcg_gen_mov_tl(cpu_tmp4, cpu_cc_srcT);
 960             gen_extu(size, cpu_tmp4);
 961             t0 = gen_ext_tl(cpu_tmp0, cpu_cc_src, size, false);
 962             cc = (CCPrepare) { .cond = TCG_COND_LEU, .reg = cpu_tmp4,
 963                                .reg2 = t0, .mask = -1, .use_reg2 = true };
 964             break;
 965
 966         case JCC_L:
 967             cond = TCG_COND_LT;
 968             goto fast_jcc_l;
 969         case JCC_LE:
 970             cond = TCG_COND_LE;
 971         fast_jcc_l:
 972             tcg_gen_mov_tl(cpu_tmp4, cpu_cc_srcT);
 973             gen_exts(size, cpu_tmp4);
 974             t0 = gen_ext_tl(cpu_tmp0, cpu_cc_src, size, true);
 975             cc = (CCPrepare) { .cond = cond, .reg = cpu_tmp4,
 976                                .reg2 = t0, .mask = -1, .use_reg2 = true };
 977             break;
 978
 979         default:
 980             goto slow_jcc;
 981         }
 982         break;
 983
 984     default:
 985     slow_jcc:
 986         /* This actually generates good code for JC, JZ and JS.  */
 987         switch (jcc_op) {
 988         case JCC_O:
 989             cc = gen_prepare_eflags_o(s, reg);
 990             break;
 991         case JCC_B:
 992             cc = gen_prepare_eflags_c(s, reg);
 993             break;
 994         case JCC_Z:
 995             cc = gen_prepare_eflags_z(s, reg);
 996             break;
 997         case JCC_BE:
 998             gen_compute_eflags(s);
 999             cc = (CCPrepare) { .cond = TCG_COND_NE, .reg = cpu_cc_src,
1000                                .mask = CC_Z | CC_C };
1001             break;
1002         case JCC_S:
1003             cc = gen_prepare_eflags_s(s, reg);
1004             break;
1005         case JCC_P:
1006             cc = gen_prepare_eflags_p(s, reg);
1007             break;
1008         case JCC_L:
1009             gen_compute_eflags(s);
1010             if (TCGV_EQUAL(reg, cpu_cc_src)) {
1011                 reg = cpu_tmp0;
1012             }
1013             tcg_gen_shri_tl(reg, cpu_cc_src, 4); /* CC_O -> CC_S */
1014             tcg_gen_xor_tl(reg, reg, cpu_cc_src);
1015             cc = (CCPrepare) { .cond = TCG_COND_NE, .reg = reg,
1016                                .mask = CC_S };
1017             break;
1018         default:
1019         case JCC_LE:
1020             gen_compute_eflags(s);
1021             if (TCGV_EQUAL(reg, cpu_cc_src)) {
1022                 reg = cpu_tmp0;
1023             }
1024             tcg_gen_shri_tl(reg, cpu_cc_src, 4); /* CC_O -> CC_S */
1025             tcg_gen_xor_tl(reg, reg, cpu_cc_src);
1026             cc = (CCPrepare) { .cond = TCG_COND_NE, .reg = reg,
1027                                .mask = CC_S | CC_Z };
1028             break;
1029         }
1030         break;
1031     }
1032
1033     if (inv) {
1034         cc.cond = tcg_invert_cond(cc.cond);
1035     }
1036     return cc;
1037 }
1038
1039 static void gen_setcc1(DisasContext *s, int b, TCGv reg)
1040 {
1041     CCPrepare cc = gen_prepare_cc(s, b, reg);
1042
1043     if (cc.no_setcond) {
1044         if (cc.cond == TCG_COND_EQ) {
1045             tcg_gen_xori_tl(reg, cc.reg, 1);
1046         } else {
1047             tcg_gen_mov_tl(reg, cc.reg);
1048         }
1049         return;
1050     }
1051
1052     if (cc.cond == TCG_COND_NE && !cc.use_reg2 && cc.imm == 0 &&
1053         cc.mask != 0 && (cc.mask & (cc.mask - 1)) == 0) {
1054         tcg_gen_shri_tl(reg, cc.reg, ctztl(cc.mask));
1055         tcg_gen_andi_tl(reg, reg, 1);
1056         return;
1057     }
1058     if (cc.mask != -1) {
1059         tcg_gen_andi_tl(reg, cc.reg, cc.mask);
1060         cc.reg = reg;
1061     }
1062     if (cc.use_reg2) {
1063         tcg_gen_setcond_tl(cc.cond, reg, cc.reg, cc.reg2);
1064     } else {
1065         tcg_gen_setcondi_tl(cc.cond, reg, cc.reg, cc.imm);
1066     }
1067 }
1068
1069 static inline void gen_compute_eflags_c(DisasContext *s, TCGv reg)
1070 {
1071     gen_setcc1(s, JCC_B << 1, reg);
1072 }
1073
1074 /* generate a conditional jump to label 'l1' according to jump opcode
1075    value 'b'. In the fast case, T0 is guaranted not to be used. */
1076 static inline void gen_jcc1_noeob(DisasContext *s, int b, int l1)
1077 {
1078     CCPrepare cc = gen_prepare_cc(s, b, cpu_T[0]);
1079
1080     if (cc.mask != -1) {
1081         tcg_gen_andi_tl(cpu_T[0], cc.reg, cc.mask);
1082         cc.reg = cpu_T[0];
1083     }
1084     if (cc.use_reg2) {
1085         tcg_gen_brcond_tl(cc.cond, cc.reg, cc.reg2, l1);
1086     } else {
1087         tcg_gen_brcondi_tl(cc.cond, cc.reg, cc.imm, l1);
1088     }
1089 }
1090
1091 /* Generate a conditional jump to label 'l1' according to jump opcode
1092    value 'b'. In the fast case, T0 is guaranted not to be used.
1093    A translation block must end soon.  */
1094 static inline void gen_jcc1(DisasContext *s, int b, int l1)
1095 {
1096     CCPrepare cc = gen_prepare_cc(s, b, cpu_T[0]);
1097
1098     gen_update_cc_op(s);
1099     if (cc.mask != -1) {
1100         tcg_gen_andi_tl(cpu_T[0], cc.reg, cc.mask);
1101         cc.reg = cpu_T[0];
1102     }
1103     set_cc_op(s, CC_OP_DYNAMIC);
1104     if (cc.use_reg2) {
1105         tcg_gen_brcond_tl(cc.cond, cc.reg, cc.reg2, l1);
1106     } else {
1107         tcg_gen_brcondi_tl(cc.cond, cc.reg, cc.imm, l1);
1108     }
1109 }
1110
1111 /* XXX: does not work with gdbstub "ice" single step - not a
1112    serious problem */
1113 static int gen_jz_ecx_string(DisasContext *s, target_ulong next_eip)
1114 {
1115     int l1, l2;
1116
1117     l1 = gen_new_label();
1118     l2 = gen_new_label();
1119     gen_op_jnz_ecx(s->aflag, l1);
1120     gen_set_label(l2);
1121     gen_jmp_tb(s, next_eip, 1);
1122     gen_set_label(l1);
1123     return l2;
1124 }
1125
1126 static inline void gen_stos(DisasContext *s, TCGMemOp ot)
1127 {
1128     gen_op_mov_v_reg(MO_32, cpu_T[0], R_EAX);
1129     gen_string_movl_A0_EDI(s);
1130     gen_op_st_v(s, ot, cpu_T[0], cpu_A0);
1131     gen_op_movl_T0_Dshift(ot);
1132     gen_op_add_reg_T0(s->aflag, R_EDI);
1133 }
1134
1135 static inline void gen_lods(DisasContext *s, TCGMemOp ot)
1136 {
1137     gen_string_movl_A0_ESI(s);
1138     gen_op_ld_v(s, ot, cpu_T[0], cpu_A0);
1139     gen_op_mov_reg_v(ot, R_EAX, cpu_T[0]);
1140     gen_op_movl_T0_Dshift(ot);
1141     gen_op_add_reg_T0(s->aflag, R_ESI);
1142 }
1143
1144 static inline void gen_scas(DisasContext *s, TCGMemOp ot)
1145 {
1146     gen_string_movl_A0_EDI(s);
1147     gen_op_ld_v(s, ot, cpu_T[1], cpu_A0);
1148     gen_op(s, OP_CMPL, ot, R_EAX);
1149     gen_op_movl_T0_Dshift(ot);
1150     gen_op_add_reg_T0(s->aflag, R_EDI);
1151 }
1152
1153 static inline void gen_cmps(DisasContext *s, TCGMemOp ot)
1154 {
1155     gen_string_movl_A0_EDI(s);
1156     gen_op_ld_v(s, ot, cpu_T[1], cpu_A0);
1157     gen_string_movl_A0_ESI(s);
1158     gen_op(s, OP_CMPL, ot, OR_TMP0);
1159     gen_op_movl_T0_Dshift(ot);
1160     gen_op_add_reg_T0(s->aflag, R_ESI);
1161     gen_op_add_reg_T0(s->aflag, R_EDI);
1162 }
1163
1164 static inline void gen_ins(DisasContext *s, TCGMemOp ot)
1165 {
1166     if (use_icount)
1167         gen_io_start();
1168     gen_string_movl_A0_EDI(s);
1169     /* Note: we must do this dummy write first to be restartable in
1170        case of page fault. */
1171     tcg_gen_movi_tl(cpu_T[0], 0);
1172     gen_op_st_v(s, ot, cpu_T[0], cpu_A0);
1173     tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_regs[R_EDX]);
1174     tcg_gen_andi_i32(cpu_tmp2_i32, cpu_tmp2_i32, 0xffff);
1175     gen_helper_in_func(ot, cpu_T[0], cpu_tmp2_i32);
1176     gen_op_st_v(s, ot, cpu_T[0], cpu_A0);
1177     gen_op_movl_T0_Dshift(ot);
1178     gen_op_add_reg_T0(s->aflag, R_EDI);
1179     if (use_icount)
1180         gen_io_end();
1181 }
1182
1183 static inline void gen_outs(DisasContext *s, TCGMemOp ot)
1184 {
1185     if (use_icount)
1186         gen_io_start();
1187     gen_string_movl_A0_ESI(s);
1188     gen_op_ld_v(s, ot, cpu_T[0], cpu_A0);
1189
1190     tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_regs[R_EDX]);
1191     tcg_gen_andi_i32(cpu_tmp2_i32, cpu_tmp2_i32, 0xffff);
1192     tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[0]);
1193     gen_helper_out_func(ot, cpu_tmp2_i32, cpu_tmp3_i32);
1194
1195     gen_op_movl_T0_Dshift(ot);
1196     gen_op_add_reg_T0(s->aflag, R_ESI);
1197     if (use_icount)
1198         gen_io_end();
1199 }
1200
1201 /* same method as Valgrind : we generate jumps to current or next
1202    instruction */
1203 #define GEN_REPZ(op)                                                          \
1204 static inline void gen_repz_ ## op(DisasContext *s, TCGMemOp ot,              \
1205                                  target_ulong cur_eip, target_ulong next_eip) \
1206 {                                                                             \
1207     int l2;\
1208     gen_update_cc_op(s);                                                      \
1209     l2 = gen_jz_ecx_string(s, next_eip);                                      \
1210     gen_ ## op(s, ot);                                                        \
1211     gen_op_add_reg_im(s->aflag, R_ECX, -1);                                   \
1212     /* a loop would cause two single step exceptions if ECX = 1               \
1213        before rep string_insn */                                              \
1214     if (!s->jmp_opt)                                                          \
1215         gen_op_jz_ecx(s->aflag, l2);                                          \
1216     gen_jmp(s, cur_eip);                                                      \
1217 }
1218
1219 #define GEN_REPZ2(op)                                                         \
1220 static inline void gen_repz_ ## op(DisasContext *s, TCGMemOp ot,              \
1221                                    target_ulong cur_eip,                      \
1222                                    target_ulong next_eip,                     \
1223                                    int nz)                                    \
1224 {                                                                             \
1225     int l2;\
1226     gen_update_cc_op(s);                                                      \
1227     l2 = gen_jz_ecx_string(s, next_eip);                                      \
1228     gen_ ## op(s, ot);                                                        \
1229     gen_op_add_reg_im(s->aflag, R_ECX, -1);                                   \
1230     gen_update_cc_op(s);                                                      \
1231     gen_jcc1(s, (JCC_Z << 1) | (nz ^ 1), l2);                                 \
1232     if (!s->jmp_opt)                                                          \
1233         gen_op_jz_ecx(s->aflag, l2);                                          \
1234     gen_jmp(s, cur_eip);                                                      \
1235 }
1236
1237 GEN_REPZ(movs)
1238 GEN_REPZ(stos)
1239 GEN_REPZ(lods)
1240 GEN_REPZ(ins)
1241 GEN_REPZ(outs)
1242 GEN_REPZ2(scas)
1243 GEN_REPZ2(cmps)
1244
1245 static void gen_helper_fp_arith_ST0_FT0(int op)
1246 {
1247     switch (op) {
1248     case 0:
1249         gen_helper_fadd_ST0_FT0(cpu_env);
1250         break;
1251     case 1:
1252         gen_helper_fmul_ST0_FT0(cpu_env);
1253         break;
1254     case 2:
1255         gen_helper_fcom_ST0_FT0(cpu_env);
1256         break;
1257     case 3:
1258         gen_helper_fcom_ST0_FT0(cpu_env);
1259         break;
1260     case 4:
1261         gen_helper_fsub_ST0_FT0(cpu_env);
1262         break;
1263     case 5:
1264         gen_helper_fsubr_ST0_FT0(cpu_env);
1265         break;
1266     case 6:
1267         gen_helper_fdiv_ST0_FT0(cpu_env);
1268         break;
1269     case 7:
1270         gen_helper_fdivr_ST0_FT0(cpu_env);
1271         break;
1272     }
1273 }
1274
1275 /* NOTE the exception in "r" op ordering */
1276 static void gen_helper_fp_arith_STN_ST0(int op, int opreg)
1277 {
1278     TCGv_i32 tmp = tcg_const_i32(opreg);
1279     switch (op) {
1280     case 0:
1281         gen_helper_fadd_STN_ST0(cpu_env, tmp);
1282         break;
1283     case 1:
1284         gen_helper_fmul_STN_ST0(cpu_env, tmp);
1285         break;
1286     case 4:
1287         gen_helper_fsubr_STN_ST0(cpu_env, tmp);
1288         break;
1289     case 5:
1290         gen_helper_fsub_STN_ST0(cpu_env, tmp);
1291         break;
1292     case 6:
1293         gen_helper_fdivr_STN_ST0(cpu_env, tmp);
1294         break;
1295     case 7:
1296         gen_helper_fdiv_STN_ST0(cpu_env, tmp);
1297         break;
1298     }
1299 }
1300
1301 /* if d == OR_TMP0, it means memory operand (address in A0) */
1302 static void gen_op(DisasContext *s1, int op, TCGMemOp ot, int d)
1303 {
1304     if (d != OR_TMP0) {
1305         gen_op_mov_v_reg(ot, cpu_T[0], d);
1306     } else {
1307         gen_op_ld_v(s1, ot, cpu_T[0], cpu_A0);
1308     }
1309     switch(op) {
1310     case OP_ADCL:
1311         gen_compute_eflags_c(s1, cpu_tmp4);
1312         tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1313         tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_tmp4);
1314         gen_op_st_rm_T0_A0(s1, ot, d);
1315         gen_op_update3_cc(cpu_tmp4);
1316         set_cc_op(s1, CC_OP_ADCB + ot);
1317         break;
1318     case OP_SBBL:
1319         gen_compute_eflags_c(s1, cpu_tmp4);
1320         tcg_gen_sub_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1321         tcg_gen_sub_tl(cpu_T[0], cpu_T[0], cpu_tmp4);
1322         gen_op_st_rm_T0_A0(s1, ot, d);
1323         gen_op_update3_cc(cpu_tmp4);
1324         set_cc_op(s1, CC_OP_SBBB + ot);
1325         break;
1326     case OP_ADDL:
1327         tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1328         gen_op_st_rm_T0_A0(s1, ot, d);
1329         gen_op_update2_cc();
1330         set_cc_op(s1, CC_OP_ADDB + ot);
1331         break;
1332     case OP_SUBL:
1333         tcg_gen_mov_tl(cpu_cc_srcT, cpu_T[0]);
1334         tcg_gen_sub_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1335         gen_op_st_rm_T0_A0(s1, ot, d);
1336         gen_op_update2_cc();
1337         set_cc_op(s1, CC_OP_SUBB + ot);
1338         break;
1339     default:
1340     case OP_ANDL:
1341         tcg_gen_and_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1342         gen_op_st_rm_T0_A0(s1, ot, d);
1343         gen_op_update1_cc();
1344         set_cc_op(s1, CC_OP_LOGICB + ot);
1345         break;
1346     case OP_ORL:
1347         tcg_gen_or_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1348         gen_op_st_rm_T0_A0(s1, ot, d);
1349         gen_op_update1_cc();
1350         set_cc_op(s1, CC_OP_LOGICB + ot);
1351         break;
1352     case OP_XORL:
1353         tcg_gen_xor_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1354         gen_op_st_rm_T0_A0(s1, ot, d);
1355         gen_op_update1_cc();
1356         set_cc_op(s1, CC_OP_LOGICB + ot);
1357         break;
1358     case OP_CMPL:
1359         tcg_gen_mov_tl(cpu_cc_src, cpu_T[1]);
1360         tcg_gen_mov_tl(cpu_cc_srcT, cpu_T[0]);
1361         tcg_gen_sub_tl(cpu_cc_dst, cpu_T[0], cpu_T[1]);
1362         set_cc_op(s1, CC_OP_SUBB + ot);
1363         break;
1364     }
1365 }
1366
1367 /* if d == OR_TMP0, it means memory operand (address in A0) */
1368 static void gen_inc(DisasContext *s1, TCGMemOp ot, int d, int c)
1369 {
1370     if (d != OR_TMP0) {
1371         gen_op_mov_v_reg(ot, cpu_T[0], d);
1372     } else {
1373         gen_op_ld_v(s1, ot, cpu_T[0], cpu_A0);
1374     }
1375     gen_compute_eflags_c(s1, cpu_cc_src);
1376     if (c > 0) {
1377         tcg_gen_addi_tl(cpu_T[0], cpu_T[0], 1);
1378         set_cc_op(s1, CC_OP_INCB + ot);
1379     } else {
1380         tcg_gen_addi_tl(cpu_T[0], cpu_T[0], -1);
1381         set_cc_op(s1, CC_OP_DECB + ot);
1382     }
1383     gen_op_st_rm_T0_A0(s1, ot, d);
1384     tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
1385 }
1386
1387 static void gen_shift_flags(DisasContext *s, TCGMemOp ot, TCGv result,
1388                             TCGv shm1, TCGv count, bool is_right)
1389 {
1390     TCGv_i32 z32, s32, oldop;
1391     TCGv z_tl;
1392
1393     /* Store the results into the CC variables.  If we know that the
1394        variable must be dead, store unconditionally.  Otherwise we'll
1395        need to not disrupt the current contents.  */
1396     z_tl = tcg_const_tl(0);
1397     if (cc_op_live[s->cc_op] & USES_CC_DST) {
1398         tcg_gen_movcond_tl(TCG_COND_NE, cpu_cc_dst, count, z_tl,
1399                            result, cpu_cc_dst);
1400     } else {
1401         tcg_gen_mov_tl(cpu_cc_dst, result);
1402     }
1403     if (cc_op_live[s->cc_op] & USES_CC_SRC) {
1404         tcg_gen_movcond_tl(TCG_COND_NE, cpu_cc_src, count, z_tl,
1405                            shm1, cpu_cc_src);
1406     } else {
1407         tcg_gen_mov_tl(cpu_cc_src, shm1);
1408     }
1409     tcg_temp_free(z_tl);
1410
1411     /* Get the two potential CC_OP values into temporaries.  */
1412     tcg_gen_movi_i32(cpu_tmp2_i32, (is_right ? CC_OP_SARB : CC_OP_SHLB) + ot);
1413     if (s->cc_op == CC_OP_DYNAMIC) {
1414         oldop = cpu_cc_op;
1415     } else {
1416         tcg_gen_movi_i32(cpu_tmp3_i32, s->cc_op);
1417         oldop = cpu_tmp3_i32;
1418     }
1419
1420     /* Conditionally store the CC_OP value.  */
1421     z32 = tcg_const_i32(0);
1422     s32 = tcg_temp_new_i32();
1423     tcg_gen_trunc_tl_i32(s32, count);
1424     tcg_gen_movcond_i32(TCG_COND_NE, cpu_cc_op, s32, z32, cpu_tmp2_i32, oldop);
1425     tcg_temp_free_i32(z32);
1426     tcg_temp_free_i32(s32);
1427
1428     /* The CC_OP value is no longer predictable.  */
1429     set_cc_op(s, CC_OP_DYNAMIC);
1430 }
1431
1432 static void gen_shift_rm_T1(DisasContext *s, TCGMemOp ot, int op1,
1433                             int is_right, int is_arith)
1434 {
1435     target_ulong mask = (ot == MO_64 ? 0x3f : 0x1f);
1436
1437     /* load */
1438     if (op1 == OR_TMP0) {
1439         gen_op_ld_v(s, ot, cpu_T[0], cpu_A0);
1440     } else {
1441         gen_op_mov_v_reg(ot, cpu_T[0], op1);
1442     }
1443
1444     tcg_gen_andi_tl(cpu_T[1], cpu_T[1], mask);
1445     tcg_gen_subi_tl(cpu_tmp0, cpu_T[1], 1);
1446
1447     if (is_right) {
1448         if (is_arith) {
1449             gen_exts(ot, cpu_T[0]);
1450             tcg_gen_sar_tl(cpu_tmp0, cpu_T[0], cpu_tmp0);
1451             tcg_gen_sar_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1452         } else {
1453             gen_extu(ot, cpu_T[0]);
1454             tcg_gen_shr_tl(cpu_tmp0, cpu_T[0], cpu_tmp0);
1455             tcg_gen_shr_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1456         }
1457     } else {
1458         tcg_gen_shl_tl(cpu_tmp0, cpu_T[0], cpu_tmp0);
1459         tcg_gen_shl_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1460     }
1461
1462     /* store */
1463     gen_op_st_rm_T0_A0(s, ot, op1);
1464
1465     gen_shift_flags(s, ot, cpu_T[0], cpu_tmp0, cpu_T[1], is_right);
1466 }
1467
1468 static void gen_shift_rm_im(DisasContext *s, TCGMemOp ot, int op1, int op2,
1469                             int is_right, int is_arith)
1470 {
1471     int mask = (ot == MO_64 ? 0x3f : 0x1f);
1472
1473     /* load */
1474     if (op1 == OR_TMP0)
1475         gen_op_ld_v(s, ot, cpu_T[0], cpu_A0);
1476     else
1477         gen_op_mov_v_reg(ot, cpu_T[0], op1);
1478
1479     op2 &= mask;
1480     if (op2 != 0) {
1481         if (is_right) {
1482             if (is_arith) {
1483                 gen_exts(ot, cpu_T[0]);
1484                 tcg_gen_sari_tl(cpu_tmp4, cpu_T[0], op2 - 1);
1485                 tcg_gen_sari_tl(cpu_T[0], cpu_T[0], op2);
1486             } else {
1487                 gen_extu(ot, cpu_T[0]);
1488                 tcg_gen_shri_tl(cpu_tmp4, cpu_T[0], op2 - 1);
1489                 tcg_gen_shri_tl(cpu_T[0], cpu_T[0], op2);
1490             }
1491         } else {
1492             tcg_gen_shli_tl(cpu_tmp4, cpu_T[0], op2 - 1);
1493             tcg_gen_shli_tl(cpu_T[0], cpu_T[0], op2);
1494         }
1495     }
1496
1497     /* store */
1498     gen_op_st_rm_T0_A0(s, ot, op1);
1499
1500     /* update eflags if non zero shift */
1501     if (op2 != 0) {
1502         tcg_gen_mov_tl(cpu_cc_src, cpu_tmp4);
1503         tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
1504         set_cc_op(s, (is_right ? CC_OP_SARB : CC_OP_SHLB) + ot);
1505     }
1506 }
1507
1508 static inline void tcg_gen_lshift(TCGv ret, TCGv arg1, target_long arg2)
1509 {
1510     if (arg2 >= 0)
1511         tcg_gen_shli_tl(ret, arg1, arg2);
1512     else
1513         tcg_gen_shri_tl(ret, arg1, -arg2);
1514 }
1515
1516 static void gen_rot_rm_T1(DisasContext *s, TCGMemOp ot, int op1, int is_right)
1517 {
1518     target_ulong mask = (ot == MO_64 ? 0x3f : 0x1f);
1519     TCGv_i32 t0, t1;
1520
1521     /* load */
1522     if (op1 == OR_TMP0) {
1523         gen_op_ld_v(s, ot, cpu_T[0], cpu_A0);
1524     } else {
1525         gen_op_mov_v_reg(ot, cpu_T[0], op1);
1526     }
1527
1528     tcg_gen_andi_tl(cpu_T[1], cpu_T[1], mask);
1529
1530     switch (ot) {
1531     case MO_8:
1532         /* Replicate the 8-bit input so that a 32-bit rotate works.  */
1533         tcg_gen_ext8u_tl(cpu_T[0], cpu_T[0]);
1534         tcg_gen_muli_tl(cpu_T[0], cpu_T[0], 0x01010101);
1535         goto do_long;
1536     case MO_16:
1537         /* Replicate the 16-bit input so that a 32-bit rotate works.  */
1538         tcg_gen_deposit_tl(cpu_T[0], cpu_T[0], cpu_T[0], 16, 16);
1539         goto do_long;
1540     do_long:
1541 #ifdef TARGET_X86_64
1542     case MO_32:
1543         tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
1544         tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[1]);
1545         if (is_right) {
1546             tcg_gen_rotr_i32(cpu_tmp2_i32, cpu_tmp2_i32, cpu_tmp3_i32);
1547         } else {
1548             tcg_gen_rotl_i32(cpu_tmp2_i32, cpu_tmp2_i32, cpu_tmp3_i32);
1549         }
1550         tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
1551         break;
1552 #endif
1553     default:
1554         if (is_right) {
1555             tcg_gen_rotr_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1556         } else {
1557             tcg_gen_rotl_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1558         }
1559         break;
1560     }
1561
1562     /* store */
1563     gen_op_st_rm_T0_A0(s, ot, op1);
1564
1565     /* We'll need the flags computed into CC_SRC.  */
1566     gen_compute_eflags(s);
1567
1568     /* The value that was "rotated out" is now present at the other end
1569        of the word.  Compute C into CC_DST and O into CC_SRC2.  Note that
1570        since we've computed the flags into CC_SRC, these variables are
1571        currently dead.  */
1572     if (is_right) {
1573         tcg_gen_shri_tl(cpu_cc_src2, cpu_T[0], mask - 1);
1574         tcg_gen_shri_tl(cpu_cc_dst, cpu_T[0], mask);
1575         tcg_gen_andi_tl(cpu_cc_dst, cpu_cc_dst, 1);
1576     } else {
1577         tcg_gen_shri_tl(cpu_cc_src2, cpu_T[0], mask);
1578         tcg_gen_andi_tl(cpu_cc_dst, cpu_T[0], 1);
1579     }
1580     tcg_gen_andi_tl(cpu_cc_src2, cpu_cc_src2, 1);
1581     tcg_gen_xor_tl(cpu_cc_src2, cpu_cc_src2, cpu_cc_dst);
1582
1583     /* Now conditionally store the new CC_OP value.  If the shift count
1584        is 0 we keep the CC_OP_EFLAGS setting so that only CC_SRC is live.
1585        Otherwise reuse CC_OP_ADCOX which have the C and O flags split out
1586        exactly as we computed above.  */
1587     t0 = tcg_const_i32(0);
1588     t1 = tcg_temp_new_i32();
1589     tcg_gen_trunc_tl_i32(t1, cpu_T[1]);
1590     tcg_gen_movi_i32(cpu_tmp2_i32, CC_OP_ADCOX);
1591     tcg_gen_movi_i32(cpu_tmp3_i32, CC_OP_EFLAGS);
1592     tcg_gen_movcond_i32(TCG_COND_NE, cpu_cc_op, t1, t0,
1593                         cpu_tmp2_i32, cpu_tmp3_i32);
1594     tcg_temp_free_i32(t0);
1595     tcg_temp_free_i32(t1);
1596
1597     /* The CC_OP value is no longer predictable.  */
1598     set_cc_op(s, CC_OP_DYNAMIC);
1599 }
1600
1601 static void gen_rot_rm_im(DisasContext *s, TCGMemOp ot, int op1, int op2,
1602                           int is_right)
1603 {
1604     int mask = (ot == MO_64 ? 0x3f : 0x1f);
1605     int shift;
1606
1607     /* load */
1608     if (op1 == OR_TMP0) {
1609         gen_op_ld_v(s, ot, cpu_T[0], cpu_A0);
1610     } else {
1611         gen_op_mov_v_reg(ot, cpu_T[0], op1);
1612     }
1613
1614     op2 &= mask;
1615     if (op2 != 0) {
1616         switch (ot) {
1617 #ifdef TARGET_X86_64
1618         case MO_32:
1619             tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
1620             if (is_right) {
1621                 tcg_gen_rotri_i32(cpu_tmp2_i32, cpu_tmp2_i32, op2);
1622             } else {
1623                 tcg_gen_rotli_i32(cpu_tmp2_i32, cpu_tmp2_i32, op2);
1624             }
1625             tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
1626             break;
1627 #endif
1628         default:
1629             if (is_right) {
1630                 tcg_gen_rotri_tl(cpu_T[0], cpu_T[0], op2);
1631             } else {
1632                 tcg_gen_rotli_tl(cpu_T[0], cpu_T[0], op2);
1633             }
1634             break;
1635         case MO_8:
1636             mask = 7;
1637             goto do_shifts;
1638         case MO_16:
1639             mask = 15;
1640         do_shifts:
1641             shift = op2 & mask;
1642             if (is_right) {
1643                 shift = mask + 1 - shift;
1644             }
1645             gen_extu(ot, cpu_T[0]);
1646             tcg_gen_shli_tl(cpu_tmp0, cpu_T[0], shift);
1647             tcg_gen_shri_tl(cpu_T[0], cpu_T[0], mask + 1 - shift);
1648             tcg_gen_or_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
1649             break;
1650         }
1651     }
1652
1653     /* store */
1654     gen_op_st_rm_T0_A0(s, ot, op1);
1655
1656     if (op2 != 0) {
1657         /* Compute the flags into CC_SRC.  */
1658         gen_compute_eflags(s);
1659
1660         /* The value that was "rotated out" is now present at the other end
1661            of the word.  Compute C into CC_DST and O into CC_SRC2.  Note that
1662            since we've computed the flags into CC_SRC, these variables are
1663            currently dead.  */
1664         if (is_right) {
1665             tcg_gen_shri_tl(cpu_cc_src2, cpu_T[0], mask - 1);
1666             tcg_gen_shri_tl(cpu_cc_dst, cpu_T[0], mask);
1667             tcg_gen_andi_tl(cpu_cc_dst, cpu_cc_dst, 1);
1668         } else {
1669             tcg_gen_shri_tl(cpu_cc_src2, cpu_T[0], mask);
1670             tcg_gen_andi_tl(cpu_cc_dst, cpu_T[0], 1);
1671         }
1672         tcg_gen_andi_tl(cpu_cc_src2, cpu_cc_src2, 1);
1673         tcg_gen_xor_tl(cpu_cc_src2, cpu_cc_src2, cpu_cc_dst);
1674         set_cc_op(s, CC_OP_ADCOX);
1675     }
1676 }
1677
1678 /* XXX: add faster immediate = 1 case */
1679 static void gen_rotc_rm_T1(DisasContext *s, TCGMemOp ot, int op1,
1680                            int is_right)
1681 {
1682     gen_compute_eflags(s);
1683     assert(s->cc_op == CC_OP_EFLAGS);
1684
1685     /* load */
1686     if (op1 == OR_TMP0)
1687         gen_op_ld_v(s, ot, cpu_T[0], cpu_A0);
1688     else
1689         gen_op_mov_v_reg(ot, cpu_T[0], op1);
1690
1691     if (is_right) {
1692         switch (ot) {
1693         case MO_8:
1694             gen_helper_rcrb(cpu_T[0], cpu_env, cpu_T[0], cpu_T[1]);
1695             break;
1696         case MO_16:
1697             gen_helper_rcrw(cpu_T[0], cpu_env, cpu_T[0], cpu_T[1]);
1698             break;
1699         case MO_32:
1700             gen_helper_rcrl(cpu_T[0], cpu_env, cpu_T[0], cpu_T[1]);
1701             break;
1702 #ifdef TARGET_X86_64
1703         case MO_64:
1704             gen_helper_rcrq(cpu_T[0], cpu_env, cpu_T[0], cpu_T[1]);
1705             break;
1706 #endif
1707         default:
1708             tcg_abort();
1709         }
1710     } else {
1711         switch (ot) {
1712         case MO_8:
1713             gen_helper_rclb(cpu_T[0], cpu_env, cpu_T[0], cpu_T[1]);
1714             break;
1715         case MO_16:
1716             gen_helper_rclw(cpu_T[0], cpu_env, cpu_T[0], cpu_T[1]);
1717             break;
1718         case MO_32:
1719             gen_helper_rcll(cpu_T[0], cpu_env, cpu_T[0], cpu_T[1]);
1720             break;
1721 #ifdef TARGET_X86_64
1722         case MO_64:
1723             gen_helper_rclq(cpu_T[0], cpu_env, cpu_T[0], cpu_T[1]);
1724             break;
1725 #endif
1726         default:
1727             tcg_abort();
1728         }
1729     }
1730     /* store */
1731     gen_op_st_rm_T0_A0(s, ot, op1);
1732 }
1733
1734 /* XXX: add faster immediate case */
1735 static void gen_shiftd_rm_T1(DisasContext *s, TCGMemOp ot, int op1,
1736                              bool is_right, TCGv count_in)
1737 {
1738     target_ulong mask = (ot == MO_64 ? 63 : 31);
1739     TCGv count;
1740
1741     /* load */
1742     if (op1 == OR_TMP0) {
1743         gen_op_ld_v(s, ot, cpu_T[0], cpu_A0);
1744     } else {
1745         gen_op_mov_v_reg(ot, cpu_T[0], op1);
1746     }
1747
1748     count = tcg_temp_new();
1749     tcg_gen_andi_tl(count, count_in, mask);
1750
1751     switch (ot) {
1752     case MO_16:
1753         /* Note: we implement the Intel behaviour for shift count > 16.
1754            This means "shrdw C, B, A" shifts A:B:A >> C.  Build the B:A
1755            portion by constructing it as a 32-bit value.  */
1756         if (is_right) {
1757             tcg_gen_deposit_tl(cpu_tmp0, cpu_T[0], cpu_T[1], 16, 16);
1758             tcg_gen_mov_tl(cpu_T[1], cpu_T[0]);
1759             tcg_gen_mov_tl(cpu_T[0], cpu_tmp0);
1760         } else {
1761             tcg_gen_deposit_tl(cpu_T[1], cpu_T[0], cpu_T[1], 16, 16);
1762         }
1763         /* FALLTHRU */
1764 #ifdef TARGET_X86_64
1765     case MO_32:
1766         /* Concatenate the two 32-bit values and use a 64-bit shift.  */
1767         tcg_gen_subi_tl(cpu_tmp0, count, 1);
1768         if (is_right) {
1769             tcg_gen_concat_tl_i64(cpu_T[0], cpu_T[0], cpu_T[1]);
1770             tcg_gen_shr_i64(cpu_tmp0, cpu_T[0], cpu_tmp0);
1771             tcg_gen_shr_i64(cpu_T[0], cpu_T[0], count);
1772         } else {
1773             tcg_gen_concat_tl_i64(cpu_T[0], cpu_T[1], cpu_T[0]);
1774             tcg_gen_shl_i64(cpu_tmp0, cpu_T[0], cpu_tmp0);
1775             tcg_gen_shl_i64(cpu_T[0], cpu_T[0], count);
1776             tcg_gen_shri_i64(cpu_tmp0, cpu_tmp0, 32);
1777             tcg_gen_shri_i64(cpu_T[0], cpu_T[0], 32);
1778         }
1779         break;
1780 #endif
1781     default:
1782         tcg_gen_subi_tl(cpu_tmp0, count, 1);
1783         if (is_right) {
1784             tcg_gen_shr_tl(cpu_tmp0, cpu_T[0], cpu_tmp0);
1785
1786             tcg_gen_subfi_tl(cpu_tmp4, mask + 1, count);
1787             tcg_gen_shr_tl(cpu_T[0], cpu_T[0], count);
1788             tcg_gen_shl_tl(cpu_T[1], cpu_T[1], cpu_tmp4);
1789         } else {
1790             tcg_gen_shl_tl(cpu_tmp0, cpu_T[0], cpu_tmp0);
1791             if (ot == MO_16) {
1792                 /* Only needed if count > 16, for Intel behaviour.  */
1793                 tcg_gen_subfi_tl(cpu_tmp4, 33, count);
1794                 tcg_gen_shr_tl(cpu_tmp4, cpu_T[1], cpu_tmp4);
1795                 tcg_gen_or_tl(cpu_tmp0, cpu_tmp0, cpu_tmp4);
1796             }
1797
1798             tcg_gen_subfi_tl(cpu_tmp4, mask + 1, count);
1799             tcg_gen_shl_tl(cpu_T[0], cpu_T[0], count);
1800             tcg_gen_shr_tl(cpu_T[1], cpu_T[1], cpu_tmp4);
1801         }
1802         tcg_gen_movi_tl(cpu_tmp4, 0);
1803         tcg_gen_movcond_tl(TCG_COND_EQ, cpu_T[1], count, cpu_tmp4,
1804                            cpu_tmp4, cpu_T[1]);
1805         tcg_gen_or_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1806         break;
1807     }
1808
1809     /* store */
1810     gen_op_st_rm_T0_A0(s, ot, op1);
1811
1812     gen_shift_flags(s, ot, cpu_T[0], cpu_tmp0, count, is_right);
1813     tcg_temp_free(count);
1814 }
1815
1816 static void gen_shift(DisasContext *s1, int op, TCGMemOp ot, int d, int s)
1817 {
1818     if (s != OR_TMP1)
1819         gen_op_mov_v_reg(ot, cpu_T[1], s);
1820     switch(op) {
1821     case OP_ROL:
1822         gen_rot_rm_T1(s1, ot, d, 0);
1823         break;
1824     case OP_ROR:
1825         gen_rot_rm_T1(s1, ot, d, 1);
1826         break;
1827     case OP_SHL:
1828     case OP_SHL1:
1829         gen_shift_rm_T1(s1, ot, d, 0, 0);
1830         break;
1831     case OP_SHR:
1832         gen_shift_rm_T1(s1, ot, d, 1, 0);
1833         break;
1834     case OP_SAR:
1835         gen_shift_rm_T1(s1, ot, d, 1, 1);
1836         break;
1837     case OP_RCL:
1838         gen_rotc_rm_T1(s1, ot, d, 0);
1839         break;
1840     case OP_RCR:
1841         gen_rotc_rm_T1(s1, ot, d, 1);
1842         break;
1843     }
1844 }
1845
1846 static void gen_shifti(DisasContext *s1, int op, TCGMemOp ot, int d, int c)
1847 {
1848     switch(op) {
1849     case OP_ROL:
1850         gen_rot_rm_im(s1, ot, d, c, 0);
1851         break;
1852     case OP_ROR:
1853         gen_rot_rm_im(s1, ot, d, c, 1);
1854         break;
1855     case OP_SHL:
1856     case OP_SHL1:
1857         gen_shift_rm_im(s1, ot, d, c, 0, 0);
1858         break;
1859     case OP_SHR:
1860         gen_shift_rm_im(s1, ot, d, c, 1, 0);
1861         break;
1862     case OP_SAR:
1863         gen_shift_rm_im(s1, ot, d, c, 1, 1);
1864         break;
1865     default:
1866         /* currently not optimized */
1867         tcg_gen_movi_tl(cpu_T[1], c);
1868         gen_shift(s1, op, ot, d, OR_TMP1);
1869         break;
1870     }
1871 }
1872
1873 static void gen_lea_modrm(CPUX86State *env, DisasContext *s, int modrm)
1874 {
1875     target_long disp;
1876     int havesib;
1877     int base;
1878     int index;
1879     int scale;
1880     int mod, rm, code, override, must_add_seg;
1881     TCGv sum;
1882
1883     override = s->override;
1884     must_add_seg = s->addseg;
1885     if (override >= 0)
1886         must_add_seg = 1;
1887     mod = (modrm >> 6) & 3;
1888     rm = modrm & 7;
1889
1890     switch (s->aflag) {
1891     case MO_64:
1892     case MO_32:
1893         havesib = 0;
1894         base = rm;
1895         index = -1;
1896         scale = 0;
1897
1898         if (base == 4) {
1899             havesib = 1;
1900             code = cpu_ldub_code(env, s->pc++);
1901             scale = (code >> 6) & 3;
1902             index = ((code >> 3) & 7) | REX_X(s);
1903             if (index == 4) {
1904                 index = -1;  /* no index */
1905             }
1906             base = (code & 7);
1907         }
1908         base |= REX_B(s);
1909
1910         switch (mod) {
1911         case 0:
1912             if ((base & 7) == 5) {
1913                 base = -1;
1914                 disp = (int32_t)cpu_ldl_code(env, s->pc);
1915                 s->pc += 4;
1916                 if (CODE64(s) && !havesib) {
1917                     disp += s->pc + s->rip_offset;
1918                 }
1919             } else {
1920                 disp = 0;
1921             }
1922             break;
1923         case 1:
1924             disp = (int8_t)cpu_ldub_code(env, s->pc++);
1925             break;
1926         default:
1927         case 2:
1928             disp = (int32_t)cpu_ldl_code(env, s->pc);
1929             s->pc += 4;
1930             break;
1931         }
1932
1933         /* For correct popl handling with esp.  */
1934         if (base == R_ESP && s->popl_esp_hack) {
1935             disp += s->popl_esp_hack;
1936         }
1937
1938         /* Compute the address, with a minimum number of TCG ops.  */
1939         TCGV_UNUSED(sum);
1940         if (index >= 0) {
1941             if (scale == 0) {
1942                 sum = cpu_regs[index];
1943             } else {
1944                 tcg_gen_shli_tl(cpu_A0, cpu_regs[index], scale);
1945                 sum = cpu_A0;
1946             }
1947             if (base >= 0) {
1948                 tcg_gen_add_tl(cpu_A0, sum, cpu_regs[base]);
1949                 sum = cpu_A0;
1950             }
1951         } else if (base >= 0) {
1952             sum = cpu_regs[base];
1953         }
1954         if (TCGV_IS_UNUSED(sum)) {
1955             tcg_gen_movi_tl(cpu_A0, disp);
1956         } else {
1957             tcg_gen_addi_tl(cpu_A0, sum, disp);
1958         }
1959
1960         if (must_add_seg) {
1961             if (override < 0) {
1962                 if (base == R_EBP || base == R_ESP) {
1963                     override = R_SS;
1964                 } else {
1965                     override = R_DS;
1966                 }
1967             }
1968
1969             tcg_gen_ld_tl(cpu_tmp0, cpu_env,
1970                           offsetof(CPUX86State, segs[override].base));
1971             if (CODE64(s)) {
1972                 if (s->aflag == MO_32) {
1973                     tcg_gen_ext32u_tl(cpu_A0, cpu_A0);
1974                 }
1975                 tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
1976                 return;
1977             }
1978
1979             tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
1980         }
1981
1982         if (s->aflag == MO_32) {
1983             tcg_gen_ext32u_tl(cpu_A0, cpu_A0);
1984         }
1985         break;
1986
1987     case MO_16:
1988         switch (mod) {
1989         case 0:
1990             if (rm == 6) {
1991                 disp = cpu_lduw_code(env, s->pc);
1992                 s->pc += 2;
1993                 tcg_gen_movi_tl(cpu_A0, disp);
1994                 rm = 0; /* avoid SS override */
1995                 goto no_rm;
1996             } else {
1997                 disp = 0;
1998             }
1999             break;
2000         case 1:
2001             disp = (int8_t)cpu_ldub_code(env, s->pc++);
2002             break;
2003         default:
2004         case 2:
2005             disp = (int16_t)cpu_lduw_code(env, s->pc);
2006             s->pc += 2;
2007             break;
2008         }
2009
2010         sum = cpu_A0;
2011         switch (rm) {
2012         case 0:
2013             tcg_gen_add_tl(cpu_A0, cpu_regs[R_EBX], cpu_regs[R_ESI]);
2014             break;
2015         case 1:
2016             tcg_gen_add_tl(cpu_A0, cpu_regs[R_EBX], cpu_regs[R_EDI]);
2017             break;
2018         case 2:
2019             tcg_gen_add_tl(cpu_A0, cpu_regs[R_EBP], cpu_regs[R_ESI]);
2020             break;
2021         case 3:
2022             tcg_gen_add_tl(cpu_A0, cpu_regs[R_EBP], cpu_regs[R_EDI]);
2023             break;
2024         case 4:
2025             sum = cpu_regs[R_ESI];
2026             break;
2027         case 5:
2028             sum = cpu_regs[R_EDI];
2029             break;
2030         case 6:
2031             sum = cpu_regs[R_EBP];
2032             break;
2033         default:
2034         case 7:
2035             sum = cpu_regs[R_EBX];
2036             break;
2037         }
2038         tcg_gen_addi_tl(cpu_A0, sum, disp);
2039         tcg_gen_ext16u_tl(cpu_A0, cpu_A0);
2040     no_rm:
2041         if (must_add_seg) {
2042             if (override < 0) {
2043                 if (rm == 2 || rm == 3 || rm == 6) {
2044                     override = R_SS;
2045                 } else {
2046                     override = R_DS;
2047                 }
2048             }
2049             gen_op_addl_A0_seg(s, override);
2050         }
2051         break;
2052
2053     default:
2054         tcg_abort();
2055     }
2056 }
2057
2058 static void gen_nop_modrm(CPUX86State *env, DisasContext *s, int modrm)
2059 {
2060     int mod, rm, base, code;
2061
2062     mod = (modrm >> 6) & 3;
2063     if (mod == 3)
2064         return;
2065     rm = modrm & 7;
2066
2067     switch (s->aflag) {
2068     case MO_64:
2069     case MO_32:
2070         base = rm;
2071
2072         if (base == 4) {
2073             code = cpu_ldub_code(env, s->pc++);
2074             base = (code & 7);
2075         }
2076
2077         switch (mod) {
2078         case 0:
2079             if (base == 5) {
2080                 s->pc += 4;
2081             }
2082             break;
2083         case 1:
2084             s->pc++;
2085             break;
2086         default:
2087         case 2:
2088             s->pc += 4;
2089             break;
2090         }
2091         break;
2092
2093     case MO_16:
2094         switch (mod) {
2095         case 0:
2096             if (rm == 6) {
2097                 s->pc += 2;
2098             }
2099             break;
2100         case 1:
2101             s->pc++;
2102             break;
2103         default:
2104         case 2:
2105             s->pc += 2;
2106             break;
2107         }
2108         break;
2109
2110     default:
2111         tcg_abort();
2112     }
2113 }
2114
2115 /* used for LEA and MOV AX, mem */
2116 static void gen_add_A0_ds_seg(DisasContext *s)
2117 {
2118     int override, must_add_seg;
2119     must_add_seg = s->addseg;
2120     override = R_DS;
2121     if (s->override >= 0) {
2122         override = s->override;
2123         must_add_seg = 1;
2124     }
2125     if (must_add_seg) {
2126 #ifdef TARGET_X86_64
2127         if (CODE64(s)) {
2128             gen_op_addq_A0_seg(override);
2129         } else
2130 #endif
2131         {
2132             gen_op_addl_A0_seg(s, override);
2133         }
2134     }
2135 }
2136
2137 /* generate modrm memory load or store of 'reg'. TMP0 is used if reg ==
2138    OR_TMP0 */
2139 static void gen_ldst_modrm(CPUX86State *env, DisasContext *s, int modrm,
2140                            TCGMemOp ot, int reg, int is_store)
2141 {
2142     int mod, rm;
2143
2144     mod = (modrm >> 6) & 3;
2145     rm = (modrm & 7) | REX_B(s);
2146     if (mod == 3) {
2147         if (is_store) {
2148             if (reg != OR_TMP0)
2149                 gen_op_mov_v_reg(ot, cpu_T[0], reg);
2150             gen_op_mov_reg_v(ot, rm, cpu_T[0]);
2151         } else {
2152             gen_op_mov_v_reg(ot, cpu_T[0], rm);
2153             if (reg != OR_TMP0)
2154                 gen_op_mov_reg_v(ot, reg, cpu_T[0]);
2155         }
2156     } else {
2157         gen_lea_modrm(env, s, modrm);
2158         if (is_store) {
2159             if (reg != OR_TMP0)
2160                 gen_op_mov_v_reg(ot, cpu_T[0], reg);
2161             gen_op_st_v(s, ot, cpu_T[0], cpu_A0);
2162         } else {
2163             gen_op_ld_v(s, ot, cpu_T[0], cpu_A0);
2164             if (reg != OR_TMP0)
2165                 gen_op_mov_reg_v(ot, reg, cpu_T[0]);
2166         }
2167     }
2168 }
2169
2170 static inline uint32_t insn_get(CPUX86State *env, DisasContext *s, TCGMemOp ot)
2171 {
2172     uint32_t ret;
2173
2174     switch (ot) {
2175     case MO_8:
2176         ret = cpu_ldub_code(env, s->pc);
2177         s->pc++;
2178         break;
2179     case MO_16:
2180         ret = cpu_lduw_code(env, s->pc);
2181         s->pc += 2;
2182         break;
2183     case MO_32:
2184 #ifdef TARGET_X86_64
2185     case MO_64:
2186 #endif
2187         ret = cpu_ldl_code(env, s->pc);
2188         s->pc += 4;
2189         break;
2190     default:
2191         tcg_abort();
2192     }
2193     return ret;
2194 }
2195
2196 static inline int insn_const_size(TCGMemOp ot)
2197 {
2198     if (ot <= MO_32) {
2199         return 1 << ot;
2200     } else {
2201         return 4;
2202     }
2203 }
2204
2205 static inline void gen_goto_tb(DisasContext *s, int tb_num, target_ulong eip)
2206 {
2207     TranslationBlock *tb;
2208     target_ulong pc;
2209
2210     pc = s->cs_base + eip;
2211     tb = s->tb;
2212     /* NOTE: we handle the case where the TB spans two pages here */
2213     if ((pc & TARGET_PAGE_MASK) == (tb->pc & TARGET_PAGE_MASK) ||
2214         (pc & TARGET_PAGE_MASK) == ((s->pc - 1) & TARGET_PAGE_MASK))  {
2215         /* jump to same page: we can use a direct jump */
2216         tcg_gen_goto_tb(tb_num);
2217         gen_jmp_im(eip);
2218         tcg_gen_exit_tb((uintptr_t)tb + tb_num);
2219     } else {
2220         /* jump to another page: currently not optimized */
2221         gen_jmp_im(eip);
2222         gen_eob(s);
2223     }
2224 }
2225
2226 static inline void gen_jcc(DisasContext *s, int b,
2227                            target_ulong val, target_ulong next_eip)
2228 {
2229     int l1, l2;
2230
2231     if (s->jmp_opt) {
2232         l1 = gen_new_label();
2233         gen_jcc1(s, b, l1);
2234
2235         gen_goto_tb(s, 0, next_eip);
2236
2237         gen_set_label(l1);
2238         gen_goto_tb(s, 1, val);
2239         s->is_jmp = DISAS_TB_JUMP;
2240     } else {
2241         l1 = gen_new_label();
2242         l2 = gen_new_label();
2243         gen_jcc1(s, b, l1);
2244
2245         gen_jmp_im(next_eip);
2246         tcg_gen_br(l2);
2247
2248         gen_set_label(l1);
2249         gen_jmp_im(val);
2250         gen_set_label(l2);
2251         gen_eob(s);
2252     }
2253 }
2254
2255 static void gen_cmovcc1(CPUX86State *env, DisasContext *s, TCGMemOp ot, int b,
2256                         int modrm, int reg)
2257 {
2258     CCPrepare cc;
2259
2260     gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
2261
2262     cc = gen_prepare_cc(s, b, cpu_T[1]);
2263     if (cc.mask != -1) {
2264         TCGv t0 = tcg_temp_new();
2265         tcg_gen_andi_tl(t0, cc.reg, cc.mask);
2266         cc.reg = t0;
2267     }
2268     if (!cc.use_reg2) {
2269         cc.reg2 = tcg_const_tl(cc.imm);
2270     }
2271
2272     tcg_gen_movcond_tl(cc.cond, cpu_T[0], cc.reg, cc.reg2,
2273                        cpu_T[0], cpu_regs[reg]);
2274     gen_op_mov_reg_v(ot, reg, cpu_T[0]);
2275
2276     if (cc.mask != -1) {
2277         tcg_temp_free(cc.reg);
2278     }
2279     if (!cc.use_reg2) {
2280         tcg_temp_free(cc.reg2);
2281     }
2282 }
2283
2284 static inline void gen_op_movl_T0_seg(int seg_reg)
2285 {
2286     tcg_gen_ld32u_tl(cpu_T[0], cpu_env,
2287                      offsetof(CPUX86State,segs[seg_reg].selector));
2288 }
2289
2290 static inline void gen_op_movl_seg_T0_vm(int seg_reg)
2291 {
2292     tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xffff);
2293     tcg_gen_st32_tl(cpu_T[0], cpu_env,
2294                     offsetof(CPUX86State,segs[seg_reg].selector));
2295     tcg_gen_shli_tl(cpu_T[0], cpu_T[0], 4);
2296     tcg_gen_st_tl(cpu_T[0], cpu_env,
2297                   offsetof(CPUX86State,segs[seg_reg].base));
2298 }
2299
2300 /* move T0 to seg_reg and compute if the CPU state may change. Never
2301    call this function with seg_reg == R_CS */
2302 static void gen_movl_seg_T0(DisasContext *s, int seg_reg, target_ulong cur_eip)
2303 {
2304     if (s->pe && !s->vm86) {
2305         /* XXX: optimize by finding processor state dynamically */
2306         gen_update_cc_op(s);
2307         gen_jmp_im(cur_eip);
2308         tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
2309         gen_helper_load_seg(cpu_env, tcg_const_i32(seg_reg), cpu_tmp2_i32);
2310         /* abort translation because the addseg value may change or
2311            because ss32 may change. For R_SS, translation must always
2312            stop as a special handling must be done to disable hardware
2313            interrupts for the next instruction */
2314         if (seg_reg == R_SS || (s->code32 && seg_reg < R_FS))
2315             s->is_jmp = DISAS_TB_JUMP;
2316     } else {
2317         gen_op_movl_seg_T0_vm(seg_reg);
2318         if (seg_reg == R_SS)
2319             s->is_jmp = DISAS_TB_JUMP;
2320     }
2321 }
2322
2323 static inline int svm_is_rep(int prefixes)
2324 {
2325     return ((prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) ? 8 : 0);
2326 }
2327
2328 static inline void
2329 gen_svm_check_intercept_param(DisasContext *s, target_ulong pc_start,
2330                               uint32_t type, uint64_t param)
2331 {
2332     /* no SVM activated; fast case */
2333     if (likely(!(s->flags & HF_SVMI_MASK)))
2334         return;
2335     gen_update_cc_op(s);
2336     gen_jmp_im(pc_start - s->cs_base);
2337     gen_helper_svm_check_intercept_param(cpu_env, tcg_const_i32(type),
2338                                          tcg_const_i64(param));
2339 }
2340
2341 static inline void
2342 gen_svm_check_intercept(DisasContext *s, target_ulong pc_start, uint64_t type)
2343 {
2344     gen_svm_check_intercept_param(s, pc_start, type, 0);
2345 }
2346
2347 static inline void gen_stack_update(DisasContext *s, int addend)
2348 {
2349 #ifdef TARGET_X86_64
2350     if (CODE64(s)) {
2351         gen_op_add_reg_im(MO_64, R_ESP, addend);
2352     } else
2353 #endif
2354     if (s->ss32) {
2355         gen_op_add_reg_im(MO_32, R_ESP, addend);
2356     } else {
2357         gen_op_add_reg_im(MO_16, R_ESP, addend);
2358     }
2359 }
2360
2361 /* Generate a push. It depends on ss32, addseg and dflag.  */
2362 static void gen_push_v(DisasContext *s, TCGv val)
2363 {
2364     TCGMemOp a_ot, d_ot = mo_pushpop(s, s->dflag);
2365     int size = 1 << d_ot;
2366     TCGv new_esp = cpu_A0;
2367
2368     tcg_gen_subi_tl(cpu_A0, cpu_regs[R_ESP], size);
2369
2370     if (CODE64(s)) {
2371         a_ot = MO_64;
2372     } else if (s->ss32) {
2373         a_ot = MO_32;
2374         if (s->addseg) {
2375             new_esp = cpu_tmp4;
2376             tcg_gen_mov_tl(new_esp, cpu_A0);
2377             gen_op_addl_A0_seg(s, R_SS);
2378         } else {
2379             tcg_gen_ext32u_tl(cpu_A0, cpu_A0);
2380         }
2381     } else {
2382         a_ot = MO_16;
2383         new_esp = cpu_tmp4;
2384         tcg_gen_ext16u_tl(cpu_A0, cpu_A0);
2385         tcg_gen_mov_tl(new_esp, cpu_A0);
2386         gen_op_addl_A0_seg(s, R_SS);
2387     }
2388
2389     gen_op_st_v(s, d_ot, val, cpu_A0);
2390     gen_op_mov_reg_v(a_ot, R_ESP, new_esp);
2391 }
2392
2393 /* two step pop is necessary for precise exceptions */
2394 static TCGMemOp gen_pop_T0(DisasContext *s)
2395 {
2396     TCGMemOp d_ot = mo_pushpop(s, s->dflag);
2397     TCGv addr = cpu_A0;
2398
2399     if (CODE64(s)) {
2400         addr = cpu_regs[R_ESP];
2401     } else if (!s->ss32) {
2402         tcg_gen_ext16u_tl(cpu_A0, cpu_regs[R_ESP]);
2403         gen_op_addl_A0_seg(s, R_SS);
2404     } else if (s->addseg) {
2405         tcg_gen_mov_tl(cpu_A0, cpu_regs[R_ESP]);
2406         gen_op_addl_A0_seg(s, R_SS);
2407     } else {
2408         tcg_gen_ext32u_tl(cpu_A0, cpu_regs[R_ESP]);
2409     }
2410
2411     gen_op_ld_v(s, d_ot, cpu_T[0], addr);
2412     return d_ot;
2413 }
2414
2415 static void gen_pop_update(DisasContext *s, TCGMemOp ot)
2416 {
2417     gen_stack_update(s, 1 << ot);
2418 }
2419
2420 static void gen_stack_A0(DisasContext *s)
2421 {
2422     gen_op_movl_A0_reg(R_ESP);
2423     if (!s->ss32)
2424         tcg_gen_ext16u_tl(cpu_A0, cpu_A0);
2425     tcg_gen_mov_tl(cpu_T[1], cpu_A0);
2426     if (s->addseg)
2427         gen_op_addl_A0_seg(s, R_SS);
2428 }
2429
2430 /* NOTE: wrap around in 16 bit not fully handled */
2431 static void gen_pusha(DisasContext *s)
2432 {
2433     int i;
2434     gen_op_movl_A0_reg(R_ESP);
2435     gen_op_addl_A0_im(-8 << s->dflag);
2436     if (!s->ss32)
2437         tcg_gen_ext16u_tl(cpu_A0, cpu_A0);
2438     tcg_gen_mov_tl(cpu_T[1], cpu_A0);
2439     if (s->addseg)
2440         gen_op_addl_A0_seg(s, R_SS);
2441     for(i = 0;i < 8; i++) {
2442         gen_op_mov_v_reg(MO_32, cpu_T[0], 7 - i);
2443         gen_op_st_v(s, s->dflag, cpu_T[0], cpu_A0);
2444         gen_op_addl_A0_im(1 << s->dflag);
2445     }
2446     gen_op_mov_reg_v(MO_16 + s->ss32, R_ESP, cpu_T[1]);
2447 }
2448
2449 /* NOTE: wrap around in 16 bit not fully handled */
2450 static void gen_popa(DisasContext *s)
2451 {
2452     int i;
2453     gen_op_movl_A0_reg(R_ESP);
2454     if (!s->ss32)
2455         tcg_gen_ext16u_tl(cpu_A0, cpu_A0);
2456     tcg_gen_mov_tl(cpu_T[1], cpu_A0);
2457     tcg_gen_addi_tl(cpu_T[1], cpu_T[1], 8 << s->dflag);
2458     if (s->addseg)
2459         gen_op_addl_A0_seg(s, R_SS);
2460     for(i = 0;i < 8; i++) {
2461         /* ESP is not reloaded */
2462         if (i != 3) {
2463             gen_op_ld_v(s, s->dflag, cpu_T[0], cpu_A0);
2464             gen_op_mov_reg_v(s->dflag, 7 - i, cpu_T[0]);
2465         }
2466         gen_op_addl_A0_im(1 << s->dflag);
2467     }
2468     gen_op_mov_reg_v(MO_16 + s->ss32, R_ESP, cpu_T[1]);
2469 }
2470
2471 static void gen_enter(DisasContext *s, int esp_addend, int level)
2472 {
2473     TCGMemOp ot = mo_pushpop(s, s->dflag);
2474     int opsize = 1 << ot;
2475
2476     level &= 0x1f;
2477 #ifdef TARGET_X86_64
2478     if (CODE64(s)) {
2479         gen_op_movl_A0_reg(R_ESP);
2480         gen_op_addq_A0_im(-opsize);
2481         tcg_gen_mov_tl(cpu_T[1], cpu_A0);
2482
2483         /* push bp */
2484         gen_op_mov_v_reg(MO_32, cpu_T[0], R_EBP);
2485         gen_op_st_v(s, ot, cpu_T[0], cpu_A0);
2486         if (level) {
2487             /* XXX: must save state */
2488             gen_helper_enter64_level(cpu_env, tcg_const_i32(level),
2489                                      tcg_const_i32((ot == MO_64)),
2490                                      cpu_T[1]);
2491         }
2492         gen_op_mov_reg_v(ot, R_EBP, cpu_T[1]);
2493         tcg_gen_addi_tl(cpu_T[1], cpu_T[1], -esp_addend + (-opsize * level));
2494         gen_op_mov_reg_v(MO_64, R_ESP, cpu_T[1]);
2495     } else
2496 #endif
2497     {
2498         gen_op_movl_A0_reg(R_ESP);
2499         gen_op_addl_A0_im(-opsize);
2500         if (!s->ss32)
2501             tcg_gen_ext16u_tl(cpu_A0, cpu_A0);
2502         tcg_gen_mov_tl(cpu_T[1], cpu_A0);
2503         if (s->addseg)
2504             gen_op_addl_A0_seg(s, R_SS);
2505         /* push bp */
2506         gen_op_mov_v_reg(MO_32, cpu_T[0], R_EBP);
2507         gen_op_st_v(s, ot, cpu_T[0], cpu_A0);
2508         if (level) {
2509             /* XXX: must save state */
2510             gen_helper_enter_level(cpu_env, tcg_const_i32(level),
2511                                    tcg_const_i32(s->dflag - 1),
2512                                    cpu_T[1]);
2513         }
2514         gen_op_mov_reg_v(ot, R_EBP, cpu_T[1]);
2515         tcg_gen_addi_tl(cpu_T[1], cpu_T[1], -esp_addend + (-opsize * level));
2516         gen_op_mov_reg_v(MO_16 + s->ss32, R_ESP, cpu_T[1]);
2517     }
2518 }
2519
2520 static void gen_exception(DisasContext *s, int trapno, target_ulong cur_eip)
2521 {
2522     gen_update_cc_op(s);
2523     gen_jmp_im(cur_eip);
2524     gen_helper_raise_exception(cpu_env, tcg_const_i32(trapno));
2525     s->is_jmp = DISAS_TB_JUMP;
2526 }
2527
2528 /* an interrupt is different from an exception because of the
2529    privilege checks */
2530 static void gen_interrupt(DisasContext *s, int intno,
2531                           target_ulong cur_eip, target_ulong next_eip)
2532 {
2533     gen_update_cc_op(s);
2534     gen_jmp_im(cur_eip);
2535     gen_helper_raise_interrupt(cpu_env, tcg_const_i32(intno),
2536                                tcg_const_i32(next_eip - cur_eip));
2537     s->is_jmp = DISAS_TB_JUMP;
2538 }
2539
2540 static void gen_debug(DisasContext *s, target_ulong cur_eip)
2541 {
2542     gen_update_cc_op(s);
2543     gen_jmp_im(cur_eip);
2544     gen_helper_debug(cpu_env);
2545     s->is_jmp = DISAS_TB_JUMP;
2546 }
2547
2548 /* generate a generic end of block. Trace exception is also generated
2549    if needed */
2550 static void gen_eob(DisasContext *s)
2551 {
2552     gen_update_cc_op(s);
2553     if (s->tb->flags & HF_INHIBIT_IRQ_MASK) {
2554         gen_helper_reset_inhibit_irq(cpu_env);
2555     }
2556     if (s->tb->flags & HF_RF_MASK) {
2557         gen_helper_reset_rf(cpu_env);
2558     }
2559     if (s->singlestep_enabled) {
2560         gen_helper_debug(cpu_env);
2561     } else if (s->tf) {
2562         gen_helper_single_step(cpu_env);
2563     } else {
2564         tcg_gen_exit_tb(0);
2565     }
2566     s->is_jmp = DISAS_TB_JUMP;
2567 }
2568
2569 /* generate a jump to eip. No segment change must happen before as a
2570    direct call to the next block may occur */
2571 static void gen_jmp_tb(DisasContext *s, target_ulong eip, int tb_num)
2572 {
2573     gen_update_cc_op(s);
2574     set_cc_op(s, CC_OP_DYNAMIC);
2575     if (s->jmp_opt) {
2576         gen_goto_tb(s, tb_num, eip);
2577         s->is_jmp = DISAS_TB_JUMP;
2578     } else {
2579         gen_jmp_im(eip);
2580         gen_eob(s);
2581     }
2582 }
2583
2584 static void gen_jmp(DisasContext *s, target_ulong eip)
2585 {
2586     gen_jmp_tb(s, eip, 0);
2587 }
2588
2589 static inline void gen_ldq_env_A0(DisasContext *s, int offset)
2590 {
2591     tcg_gen_qemu_ld_i64(cpu_tmp1_i64, cpu_A0, s->mem_index, MO_LEQ);
2592     tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, offset);
2593 }
2594
2595 static inline void gen_stq_env_A0(DisasContext *s, int offset)
2596 {
2597     tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, offset);
2598     tcg_gen_qemu_st_i64(cpu_tmp1_i64, cpu_A0, s->mem_index, MO_LEQ);
2599 }
2600
2601 static inline void gen_ldo_env_A0(DisasContext *s, int offset)
2602 {
2603     int mem_index = s->mem_index;
2604     tcg_gen_qemu_ld_i64(cpu_tmp1_i64, cpu_A0, mem_index, MO_LEQ);
2605     tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(XMMReg, XMM_Q(0)));
2606     tcg_gen_addi_tl(cpu_tmp0, cpu_A0, 8);
2607     tcg_gen_qemu_ld_i64(cpu_tmp1_i64, cpu_tmp0, mem_index, MO_LEQ);
2608     tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(XMMReg, XMM_Q(1)));
2609 }
2610
2611 static inline void gen_sto_env_A0(DisasContext *s, int offset)
2612 {
2613     int mem_index = s->mem_index;
2614     tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(XMMReg, XMM_Q(0)));
2615     tcg_gen_qemu_st_i64(cpu_tmp1_i64, cpu_A0, mem_index, MO_LEQ);
2616     tcg_gen_addi_tl(cpu_tmp0, cpu_A0, 8);
2617     tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(XMMReg, XMM_Q(1)));
2618     tcg_gen_qemu_st_i64(cpu_tmp1_i64, cpu_tmp0, mem_index, MO_LEQ);
2619 }
2620
2621 static inline void gen_op_movo(int d_offset, int s_offset)
2622 {
2623     tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, s_offset);
2624     tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset);
2625     tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, s_offset + 8);
2626     tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset + 8);
2627 }
2628
2629 static inline void gen_op_movq(int d_offset, int s_offset)
2630 {
2631     tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, s_offset);
2632     tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset);
2633 }
2634
2635 static inline void gen_op_movl(int d_offset, int s_offset)
2636 {
2637     tcg_gen_ld_i32(cpu_tmp2_i32, cpu_env, s_offset);
2638     tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, d_offset);
2639 }
2640
2641 static inline void gen_op_movq_env_0(int d_offset)
2642 {
2643     tcg_gen_movi_i64(cpu_tmp1_i64, 0);
2644     tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset);
2645 }
2646
2647 typedef void (*SSEFunc_i_ep)(TCGv_i32 val, TCGv_ptr env, TCGv_ptr reg);
2648 typedef void (*SSEFunc_l_ep)(TCGv_i64 val, TCGv_ptr env, TCGv_ptr reg);
2649 typedef void (*SSEFunc_0_epi)(TCGv_ptr env, TCGv_ptr reg, TCGv_i32 val);
2650 typedef void (*SSEFunc_0_epl)(TCGv_ptr env, TCGv_ptr reg, TCGv_i64 val);
2651 typedef void (*SSEFunc_0_epp)(TCGv_ptr env, TCGv_ptr reg_a, TCGv_ptr reg_b);
2652 typedef void (*SSEFunc_0_eppi)(TCGv_ptr env, TCGv_ptr reg_a, TCGv_ptr reg_b,
2653                                TCGv_i32 val);
2654 typedef void (*SSEFunc_0_ppi)(TCGv_ptr reg_a, TCGv_ptr reg_b, TCGv_i32 val);
2655 typedef void (*SSEFunc_0_eppt)(TCGv_ptr env, TCGv_ptr reg_a, TCGv_ptr reg_b,
2656                                TCGv val);
2657
2658 #define SSE_SPECIAL ((void *)1)
2659 #define SSE_DUMMY ((void *)2)
2660
2661 #define MMX_OP2(x) { gen_helper_ ## x ## _mmx, gen_helper_ ## x ## _xmm }
2662 #define SSE_FOP(x) { gen_helper_ ## x ## ps, gen_helper_ ## x ## pd, \
2663                      gen_helper_ ## x ## ss, gen_helper_ ## x ## sd, }
2664
2665 static const SSEFunc_0_epp sse_op_table1[256][4] = {
2666     /* 3DNow! extensions */
2667     [0x0e] = { SSE_DUMMY }, /* femms */
2668     [0x0f] = { SSE_DUMMY }, /* pf... */
2669     /* pure SSE operations */
2670     [0x10] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movups, movupd, movss, movsd */
2671     [0x11] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movups, movupd, movss, movsd */
2672     [0x12] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movlps, movlpd, movsldup, movddup */
2673     [0x13] = { SSE_SPECIAL, SSE_SPECIAL },  /* movlps, movlpd */
2674     [0x14] = { gen_helper_punpckldq_xmm, gen_helper_punpcklqdq_xmm },
2675     [0x15] = { gen_helper_punpckhdq_xmm, gen_helper_punpckhqdq_xmm },
2676     [0x16] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL },  /* movhps, movhpd, movshdup */
2677     [0x17] = { SSE_SPECIAL, SSE_SPECIAL },  /* movhps, movhpd */
2678
2679     [0x28] = { SSE_SPECIAL, SSE_SPECIAL },  /* movaps, movapd */
2680     [0x29] = { SSE_SPECIAL, SSE_SPECIAL },  /* movaps, movapd */
2681     [0x2a] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* cvtpi2ps, cvtpi2pd, cvtsi2ss, cvtsi2sd */
2682     [0x2b] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movntps, movntpd, movntss, movntsd */
2683     [0x2c] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* cvttps2pi, cvttpd2pi, cvttsd2si, cvttss2si */
2684     [0x2d] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* cvtps2pi, cvtpd2pi, cvtsd2si, cvtss2si */
2685     [0x2e] = { gen_helper_ucomiss, gen_helper_ucomisd },
2686     [0x2f] = { gen_helper_comiss, gen_helper_comisd },
2687     [0x50] = { SSE_SPECIAL, SSE_SPECIAL }, /* movmskps, movmskpd */
2688     [0x51] = SSE_FOP(sqrt),
2689     [0x52] = { gen_helper_rsqrtps, NULL, gen_helper_rsqrtss, NULL },
2690     [0x53] = { gen_helper_rcpps, NULL, gen_helper_rcpss, NULL },
2691     [0x54] = { gen_helper_pand_xmm, gen_helper_pand_xmm }, /* andps, andpd */
2692     [0x55] = { gen_helper_pandn_xmm, gen_helper_pandn_xmm }, /* andnps, andnpd */
2693     [0x56] = { gen_helper_por_xmm, gen_helper_por_xmm }, /* orps, orpd */
2694     [0x57] = { gen_helper_pxor_xmm, gen_helper_pxor_xmm }, /* xorps, xorpd */
2695     [0x58] = SSE_FOP(add),
2696     [0x59] = SSE_FOP(mul),
2697     [0x5a] = { gen_helper_cvtps2pd, gen_helper_cvtpd2ps,
2698                gen_helper_cvtss2sd, gen_helper_cvtsd2ss },
2699     [0x5b] = { gen_helper_cvtdq2ps, gen_helper_cvtps2dq, gen_helper_cvttps2dq },
2700     [0x5c] = SSE_FOP(sub),
2701     [0x5d] = SSE_FOP(min),
2702     [0x5e] = SSE_FOP(div),
2703     [0x5f] = SSE_FOP(max),
2704
2705     [0xc2] = SSE_FOP(cmpeq),
2706     [0xc6] = { (SSEFunc_0_epp)gen_helper_shufps,
2707                (SSEFunc_0_epp)gen_helper_shufpd }, /* XXX: casts */
2708
2709     /* SSSE3, SSE4, MOVBE, CRC32, BMI1, BMI2, ADX.  */
2710     [0x38] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL },
2711     [0x3a] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL },
2712
2713     /* MMX ops and their SSE extensions */
2714     [0x60] = MMX_OP2(punpcklbw),
2715     [0x61] = MMX_OP2(punpcklwd),
2716     [0x62] = MMX_OP2(punpckldq),
2717     [0x63] = MMX_OP2(packsswb),
2718     [0x64] = MMX_OP2(pcmpgtb),
2719     [0x65] = MMX_OP2(pcmpgtw),
2720     [0x66] = MMX_OP2(pcmpgtl),
2721     [0x67] = MMX_OP2(packuswb),
2722     [0x68] = MMX_OP2(punpckhbw),
2723     [0x69] = MMX_OP2(punpckhwd),
2724     [0x6a] = MMX_OP2(punpckhdq),
2725     [0x6b] = MMX_OP2(packssdw),
2726     [0x6c] = { NULL, gen_helper_punpcklqdq_xmm },
2727     [0x6d] = { NULL, gen_helper_punpckhqdq_xmm },
2728     [0x6e] = { SSE_SPECIAL, SSE_SPECIAL }, /* movd mm, ea */
2729     [0x6f] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movq, movdqa, , movqdu */
2730     [0x70] = { (SSEFunc_0_epp)gen_helper_pshufw_mmx,
2731                (SSEFunc_0_epp)gen_helper_pshufd_xmm,
2732                (SSEFunc_0_epp)gen_helper_pshufhw_xmm,
2733                (SSEFunc_0_epp)gen_helper_pshuflw_xmm }, /* XXX: casts */
2734     [0x71] = { SSE_SPECIAL, SSE_SPECIAL }, /* shiftw */
2735     [0x72] = { SSE_SPECIAL, SSE_SPECIAL }, /* shiftd */
2736     [0x73] = { SSE_SPECIAL, SSE_SPECIAL }, /* shiftq */
2737     [0x74] = MMX_OP2(pcmpeqb),
2738     [0x75] = MMX_OP2(pcmpeqw),
2739     [0x76] = MMX_OP2(pcmpeql),
2740     [0x77] = { SSE_DUMMY }, /* emms */
2741     [0x78] = { NULL, SSE_SPECIAL, NULL, SSE_SPECIAL }, /* extrq_i, insertq_i */
2742     [0x79] = { NULL, gen_helper_extrq_r, NULL, gen_helper_insertq_r },
2743     [0x7c] = { NULL, gen_helper_haddpd, NULL, gen_helper_haddps },
2744     [0x7d] = { NULL, gen_helper_hsubpd, NULL, gen_helper_hsubps },
2745     [0x7e] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movd, movd, , movq */
2746     [0x7f] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movq, movdqa, movdqu */
2747     [0xc4] = { SSE_SPECIAL, SSE_SPECIAL }, /* pinsrw */
2748     [0xc5] = { SSE_SPECIAL, SSE_SPECIAL }, /* pextrw */
2749     [0xd0] = { NULL, gen_helper_addsubpd, NULL, gen_helper_addsubps },
2750     [0xd1] = MMX_OP2(psrlw),
2751     [0xd2] = MMX_OP2(psrld),
2752     [0xd3] = MMX_OP2(psrlq),
2753     [0xd4] = MMX_OP2(paddq),
2754     [0xd5] = MMX_OP2(pmullw),
2755     [0xd6] = { NULL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL },
2756     [0xd7] = { SSE_SPECIAL, SSE_SPECIAL }, /* pmovmskb */
2757     [0xd8] = MMX_OP2(psubusb),
2758     [0xd9] = MMX_OP2(psubusw),
2759     [0xda] = MMX_OP2(pminub),
2760     [0xdb] = MMX_OP2(pand),
2761     [0xdc] = MMX_OP2(paddusb),
2762     [0xdd] = MMX_OP2(paddusw),
2763     [0xde] = MMX_OP2(pmaxub),
2764     [0xdf] = MMX_OP2(pandn),
2765     [0xe0] = MMX_OP2(pavgb),
2766     [0xe1] = MMX_OP2(psraw),
2767     [0xe2] = MMX_OP2(psrad),
2768     [0xe3] = MMX_OP2(pavgw),
2769     [0xe4] = MMX_OP2(pmulhuw),
2770     [0xe5] = MMX_OP2(pmulhw),
2771     [0xe6] = { NULL, gen_helper_cvttpd2dq, gen_helper_cvtdq2pd, gen_helper_cvtpd2dq },
2772     [0xe7] = { SSE_SPECIAL , SSE_SPECIAL },  /* movntq, movntq */
2773     [0xe8] = MMX_OP2(psubsb),
2774     [0xe9] = MMX_OP2(psubsw),
2775     [0xea] = MMX_OP2(pminsw),
2776     [0xeb] = MMX_OP2(por),
2777     [0xec] = MMX_OP2(paddsb),
2778     [0xed] = MMX_OP2(paddsw),
2779     [0xee] = MMX_OP2(pmaxsw),
2780     [0xef] = MMX_OP2(pxor),
2781     [0xf0] = { NULL, NULL, NULL, SSE_SPECIAL }, /* lddqu */
2782     [0xf1] = MMX_OP2(psllw),
2783     [0xf2] = MMX_OP2(pslld),
2784     [0xf3] = MMX_OP2(psllq),
2785     [0xf4] = MMX_OP2(pmuludq),
2786     [0xf5] = MMX_OP2(pmaddwd),
2787     [0xf6] = MMX_OP2(psadbw),
2788     [0xf7] = { (SSEFunc_0_epp)gen_helper_maskmov_mmx,
2789                (SSEFunc_0_epp)gen_helper_maskmov_xmm }, /* XXX: casts */
2790     [0xf8] = MMX_OP2(psubb),
2791     [0xf9] = MMX_OP2(psubw),
2792     [0xfa] = MMX_OP2(psubl),
2793     [0xfb] = MMX_OP2(psubq),
2794     [0xfc] = MMX_OP2(paddb),
2795     [0xfd] = MMX_OP2(paddw),
2796     [0xfe] = MMX_OP2(paddl),
2797 };
2798
2799 static const SSEFunc_0_epp sse_op_table2[3 * 8][2] = {
2800     [0 + 2] = MMX_OP2(psrlw),
2801     [0 + 4] = MMX_OP2(psraw),
2802     [0 + 6] = MMX_OP2(psllw),
2803     [8 + 2] = MMX_OP2(psrld),
2804     [8 + 4] = MMX_OP2(psrad),
2805     [8 + 6] = MMX_OP2(pslld),
2806     [16 + 2] = MMX_OP2(psrlq),
2807     [16 + 3] = { NULL, gen_helper_psrldq_xmm },
2808     [16 + 6] = MMX_OP2(psllq),
2809     [16 + 7] = { NULL, gen_helper_pslldq_xmm },
2810 };
2811
2812 static const SSEFunc_0_epi sse_op_table3ai[] = {
2813     gen_helper_cvtsi2ss,
2814     gen_helper_cvtsi2sd
2815 };
2816
2817 #ifdef TARGET_X86_64
2818 static const SSEFunc_0_epl sse_op_table3aq[] = {
2819     gen_helper_cvtsq2ss,
2820     gen_helper_cvtsq2sd
2821 };
2822 #endif
2823
2824 static const SSEFunc_i_ep sse_op_table3bi[] = {
2825     gen_helper_cvttss2si,
2826     gen_helper_cvtss2si,
2827     gen_helper_cvttsd2si,
2828     gen_helper_cvtsd2si
2829 };
2830
2831 #ifdef TARGET_X86_64
2832 static const SSEFunc_l_ep sse_op_table3bq[] = {
2833     gen_helper_cvttss2sq,
2834     gen_helper_cvtss2sq,
2835     gen_helper_cvttsd2sq,
2836     gen_helper_cvtsd2sq
2837 };
2838 #endif
2839
2840 static const SSEFunc_0_epp sse_op_table4[8][4] = {
2841     SSE_FOP(cmpeq),
2842     SSE_FOP(cmplt),
2843     SSE_FOP(cmple),
2844     SSE_FOP(cmpunord),
2845     SSE_FOP(cmpneq),
2846     SSE_FOP(cmpnlt),
2847     SSE_FOP(cmpnle),
2848     SSE_FOP(cmpord),
2849 };
2850
2851 static const SSEFunc_0_epp sse_op_table5[256] = {
2852     [0x0c] = gen_helper_pi2fw,
2853     [0x0d] = gen_helper_pi2fd,
2854     [0x1c] = gen_helper_pf2iw,
2855     [0x1d] = gen_helper_pf2id,
2856     [0x8a] = gen_helper_pfnacc,
2857     [0x8e] = gen_helper_pfpnacc,
2858     [0x90] = gen_helper_pfcmpge,
2859     [0x94] = gen_helper_pfmin,
2860     [0x96] = gen_helper_pfrcp,
2861     [0x97] = gen_helper_pfrsqrt,
2862     [0x9a] = gen_helper_pfsub,
2863     [0x9e] = gen_helper_pfadd,
2864     [0xa0] = gen_helper_pfcmpgt,
2865     [0xa4] = gen_helper_pfmax,
2866     [0xa6] = gen_helper_movq, /* pfrcpit1; no need to actually increase precision */
2867     [0xa7] = gen_helper_movq, /* pfrsqit1 */
2868     [0xaa] = gen_helper_pfsubr,
2869     [0xae] = gen_helper_pfacc,
2870     [0xb0] = gen_helper_pfcmpeq,
2871     [0xb4] = gen_helper_pfmul,
2872     [0xb6] = gen_helper_movq, /* pfrcpit2 */
2873     [0xb7] = gen_helper_pmulhrw_mmx,
2874     [0xbb] = gen_helper_pswapd,
2875     [0xbf] = gen_helper_pavgb_mmx /* pavgusb */
2876 };
2877
2878 struct SSEOpHelper_epp {
2879     SSEFunc_0_epp op[2];
2880     uint32_t ext_mask;
2881 };
2882
2883 struct SSEOpHelper_eppi {
2884     SSEFunc_0_eppi op[2];
2885     uint32_t ext_mask;
2886 };
2887
2888 #define SSSE3_OP(x) { MMX_OP2(x), CPUID_EXT_SSSE3 }
2889 #define SSE41_OP(x) { { NULL, gen_helper_ ## x ## _xmm }, CPUID_EXT_SSE41 }
2890 #define SSE42_OP(x) { { NULL, gen_helper_ ## x ## _xmm }, CPUID_EXT_SSE42 }
2891 #define SSE41_SPECIAL { { NULL, SSE_SPECIAL }, CPUID_EXT_SSE41 }
2892 #define PCLMULQDQ_OP(x) { { NULL, gen_helper_ ## x ## _xmm }, \
2893         CPUID_EXT_PCLMULQDQ }
2894 #define AESNI_OP(x) { { NULL, gen_helper_ ## x ## _xmm }, CPUID_EXT_AES }
2895
2896 static const struct SSEOpHelper_epp sse_op_table6[256] = {
2897     [0x00] = SSSE3_OP(pshufb),
2898     [0x01] = SSSE3_OP(phaddw),
2899     [0x02] = SSSE3_OP(phaddd),
2900     [0x03] = SSSE3_OP(phaddsw),
2901     [0x04] = SSSE3_OP(pmaddubsw),
2902     [0x05] = SSSE3_OP(phsubw),
2903     [0x06] = SSSE3_OP(phsubd),
2904     [0x07] = SSSE3_OP(phsubsw),
2905     [0x08] = SSSE3_OP(psignb),
2906     [0x09] = SSSE3_OP(psignw),
2907     [0x0a] = SSSE3_OP(psignd),
2908     [0x0b] = SSSE3_OP(pmulhrsw),
2909     [0x10] = SSE41_OP(pblendvb),
2910     [0x14] = SSE41_OP(blendvps),
2911     [0x15] = SSE41_OP(blendvpd),
2912     [0x17] = SSE41_OP(ptest),
2913     [0x1c] = SSSE3_OP(pabsb),
2914     [0x1d] = SSSE3_OP(pabsw),
2915     [0x1e] = SSSE3_OP(pabsd),
2916     [0x20] = SSE41_OP(pmovsxbw),
2917     [0x21] = SSE41_OP(pmovsxbd),
2918     [0x22] = SSE41_OP(pmovsxbq),
2919     [0x23] = SSE41_OP(pmovsxwd),
2920     [0x24] = SSE41_OP(pmovsxwq),
2921     [0x25] = SSE41_OP(pmovsxdq),
2922     [0x28] = SSE41_OP(pmuldq),
2923     [0x29] = SSE41_OP(pcmpeqq),
2924     [0x2a] = SSE41_SPECIAL, /* movntqda */
2925     [0x2b] = SSE41_OP(packusdw),
2926     [0x30] = SSE41_OP(pmovzxbw),
2927     [0x31] = SSE41_OP(pmovzxbd),
2928     [0x32] = SSE41_OP(pmovzxbq),
2929     [0x33] = SSE41_OP(pmovzxwd),
2930     [0x34] = SSE41_OP(pmovzxwq),
2931     [0x35] = SSE41_OP(pmovzxdq),
2932     [0x37] = SSE42_OP(pcmpgtq),
2933     [0x38] = SSE41_OP(pminsb),
2934     [0x39] = SSE41_OP(pminsd),
2935     [0x3a] = SSE41_OP(pminuw),
2936     [0x3b] = SSE41_OP(pminud),
2937     [0x3c] = SSE41_OP(pmaxsb),
2938     [0x3d] = SSE41_OP(pmaxsd),
2939     [0x3e] = SSE41_OP(pmaxuw),
2940     [0x3f] = SSE41_OP(pmaxud),
2941     [0x40] = SSE41_OP(pmulld),
2942     [0x41] = SSE41_OP(phminposuw),
2943     [0xdb] = AESNI_OP(aesimc),
2944     [0xdc] = AESNI_OP(aesenc),
2945     [0xdd] = AESNI_OP(aesenclast),
2946     [0xde] = AESNI_OP(aesdec),
2947     [0xdf] = AESNI_OP(aesdeclast),
2948 };
2949
2950 static const struct SSEOpHelper_eppi sse_op_table7[256] = {
2951     [0x08] = SSE41_OP(roundps),
2952     [0x09] = SSE41_OP(roundpd),
2953     [0x0a] = SSE41_OP(roundss),
2954     [0x0b] = SSE41_OP(roundsd),
2955     [0x0c] = SSE41_OP(blendps),
2956     [0x0d] = SSE41_OP(blendpd),
2957     [0x0e] = SSE41_OP(pblendw),
2958     [0x0f] = SSSE3_OP(palignr),
2959     [0x14] = SSE41_SPECIAL, /* pextrb */
2960     [0x15] = SSE41_SPECIAL, /* pextrw */
2961     [0x16] = SSE41_SPECIAL, /* pextrd/pextrq */
2962     [0x17] = SSE41_SPECIAL, /* extractps */
2963     [0x20] = SSE41_SPECIAL, /* pinsrb */
2964     [0x21] = SSE41_SPECIAL, /* insertps */
2965     [0x22] = SSE41_SPECIAL, /* pinsrd/pinsrq */
2966     [0x40] = SSE41_OP(dpps),
2967     [0x41] = SSE41_OP(dppd),
2968     [0x42] = SSE41_OP(mpsadbw),
2969     [0x44] = PCLMULQDQ_OP(pclmulqdq),
2970     [0x60] = SSE42_OP(pcmpestrm),
2971     [0x61] = SSE42_OP(pcmpestri),
2972     [0x62] = SSE42_OP(pcmpistrm),
2973     [0x63] = SSE42_OP(pcmpistri),
2974     [0xdf] = AESNI_OP(aeskeygenassist),
2975 };
2976
2977 static void gen_sse(CPUX86State *env, DisasContext *s, int b,
2978                     target_ulong pc_start, int rex_r)
2979 {
2980     int b1, op1_offset, op2_offset, is_xmm, val;
2981     int modrm, mod, rm, reg;
2982     SSEFunc_0_epp sse_fn_epp;
2983     SSEFunc_0_eppi sse_fn_eppi;
2984     SSEFunc_0_ppi sse_fn_ppi;
2985     SSEFunc_0_eppt sse_fn_eppt;
2986     TCGMemOp ot;
2987
2988     b &= 0xff;
2989     if (s->prefix & PREFIX_DATA)
2990         b1 = 1;
2991     else if (s->prefix & PREFIX_REPZ)
2992         b1 = 2;
2993     else if (s->prefix & PREFIX_REPNZ)
2994         b1 = 3;
2995     else
2996         b1 = 0;
2997     sse_fn_epp = sse_op_table1[b][b1];
2998     if (!sse_fn_epp) {
2999         goto illegal_op;
3000     }
3001     if ((b <= 0x5f && b >= 0x10) || b == 0xc6 || b == 0xc2) {
3002         is_xmm = 1;
3003     } else {
3004         if (b1 == 0) {
3005             /* MMX case */
3006             is_xmm = 0;
3007         } else {
3008             is_xmm = 1;
3009         }
3010     }
3011     /* simple MMX/SSE operation */
3012     if (s->flags & HF_TS_MASK) {
3013         gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
3014         return;
3015     }
3016     if (s->flags & HF_EM_MASK) {
3017     illegal_op:
3018         gen_exception(s, EXCP06_ILLOP, pc_start - s->cs_base);
3019         return;
3020     }
3021     if (is_xmm && !(s->flags & HF_OSFXSR_MASK))
3022         if ((b != 0x38 && b != 0x3a) || (s->prefix & PREFIX_DATA))
3023             goto illegal_op;
3024     if (b == 0x0e) {
3025         if (!(s->cpuid_ext2_features & CPUID_EXT2_3DNOW))
3026             goto illegal_op;
3027         /* femms */
3028         gen_helper_emms(cpu_env);
3029         return;
3030     }
3031     if (b == 0x77) {
3032         /* emms */
3033         gen_helper_emms(cpu_env);
3034         return;
3035     }
3036     /* prepare MMX state (XXX: optimize by storing fptt and fptags in
3037        the static cpu state) */
3038     if (!is_xmm) {
3039         gen_helper_enter_mmx(cpu_env);
3040     }
3041
3042     modrm = cpu_ldub_code(env, s->pc++);
3043     reg = ((modrm >> 3) & 7);
3044     if (is_xmm)
3045         reg |= rex_r;
3046     mod = (modrm >> 6) & 3;
3047     if (sse_fn_epp == SSE_SPECIAL) {
3048         b |= (b1 << 8);
3049         switch(b) {
3050         case 0x0e7: /* movntq */
3051             if (mod == 3)
3052                 goto illegal_op;
3053             gen_lea_modrm(env, s, modrm);
3054             gen_stq_env_A0(s, offsetof(CPUX86State, fpregs[reg].mmx));
3055             break;
3056         case 0x1e7: /* movntdq */
3057         case 0x02b: /* movntps */
3058         case 0x12b: /* movntps */
3059             if (mod == 3)
3060                 goto illegal_op;
3061             gen_lea_modrm(env, s, modrm);
3062             gen_sto_env_A0(s, offsetof(CPUX86State, xmm_regs[reg]));
3063             break;
3064         case 0x3f0: /* lddqu */
3065             if (mod == 3)
3066                 goto illegal_op;
3067             gen_lea_modrm(env, s, modrm);
3068             gen_ldo_env_A0(s, offsetof(CPUX86State, xmm_regs[reg]));
3069             break;
3070         case 0x22b: /* movntss */
3071         case 0x32b: /* movntsd */
3072             if (mod == 3)
3073                 goto illegal_op;
3074             gen_lea_modrm(env, s, modrm);
3075             if (b1 & 1) {
3076                 gen_stq_env_A0(s, offsetof(CPUX86State, xmm_regs[reg]));
3077             } else {
3078                 tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,
3079                     xmm_regs[reg].XMM_L(0)));
3080                 gen_op_st_v(s, MO_32, cpu_T[0], cpu_A0);
3081             }
3082             break;
3083         case 0x6e: /* movd mm, ea */
3084 #ifdef TARGET_X86_64
3085             if (s->dflag == MO_64) {
3086                 gen_ldst_modrm(env, s, modrm, MO_64, OR_TMP0, 0);
3087                 tcg_gen_st_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,fpregs[reg].mmx));
3088             } else
3089 #endif
3090             {
3091                 gen_ldst_modrm(env, s, modrm, MO_32, OR_TMP0, 0);
3092                 tcg_gen_addi_ptr(cpu_ptr0, cpu_env,
3093                                  offsetof(CPUX86State,fpregs[reg].mmx));
3094                 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
3095                 gen_helper_movl_mm_T0_mmx(cpu_ptr0, cpu_tmp2_i32);
3096             }
3097             break;
3098         case 0x16e: /* movd xmm, ea */
3099 #ifdef TARGET_X86_64
3100             if (s->dflag == MO_64) {
3101                 gen_ldst_modrm(env, s, modrm, MO_64, OR_TMP0, 0);
3102                 tcg_gen_addi_ptr(cpu_ptr0, cpu_env,
3103                                  offsetof(CPUX86State,xmm_regs[reg]));
3104                 gen_helper_movq_mm_T0_xmm(cpu_ptr0, cpu_T[0]);
3105             } else
3106 #endif
3107             {
3108                 gen_ldst_modrm(env, s, modrm, MO_32, OR_TMP0, 0);
3109                 tcg_gen_addi_ptr(cpu_ptr0, cpu_env,
3110                                  offsetof(CPUX86State,xmm_regs[reg]));
3111                 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
3112                 gen_helper_movl_mm_T0_xmm(cpu_ptr0, cpu_tmp2_i32);
3113             }
3114             break;
3115         case 0x6f: /* movq mm, ea */
3116             if (mod != 3) {
3117                 gen_lea_modrm(env, s, modrm);
3118                 gen_ldq_env_A0(s, offsetof(CPUX86State, fpregs[reg].mmx));
3119             } else {
3120                 rm = (modrm & 7);
3121                 tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env,
3122                                offsetof(CPUX86State,fpregs[rm].mmx));
3123                 tcg_gen_st_i64(cpu_tmp1_i64, cpu_env,
3124                                offsetof(CPUX86State,fpregs[reg].mmx));
3125             }
3126             break;
3127         case 0x010: /* movups */
3128         case 0x110: /* movupd */
3129         case 0x028: /* movaps */
3130         case 0x128: /* movapd */
3131         case 0x16f: /* movdqa xmm, ea */
3132         case 0x26f: /* movdqu xmm, ea */
3133             if (mod != 3) {
3134                 gen_lea_modrm(env, s, modrm);
3135                 gen_ldo_env_A0(s, offsetof(CPUX86State, xmm_regs[reg]));
3136             } else {
3137                 rm = (modrm & 7) | REX_B(s);
3138                 gen_op_movo(offsetof(CPUX86State,xmm_regs[reg]),
3139                             offsetof(CPUX86State,xmm_regs[rm]));
3140             }
3141             break;
3142         case 0x210: /* movss xmm, ea */
3143             if (mod != 3) {
3144                 gen_lea_modrm(env, s, modrm);
3145                 gen_op_ld_v(s, MO_32, cpu_T[0], cpu_A0);
3146                 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)));
3147                 tcg_gen_movi_tl(cpu_T[0], 0);
3148                 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_regs[reg].XMM_L(1)));
3149                 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_regs[reg].XMM_L(2)));
3150                 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_regs[reg].XMM_L(3)));
3151             } else {
3152                 rm = (modrm & 7) | REX_B(s);
3153                 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)),
3154                             offsetof(CPUX86State,xmm_regs[rm].XMM_L(0)));
3155             }
3156             break;
3157         case 0x310: /* movsd xmm, ea */
3158             if (mod != 3) {
3159                 gen_lea_modrm(env, s, modrm);
3160                 gen_ldq_env_A0(s, offsetof(CPUX86State,
3161                                            xmm_regs[reg].XMM_Q(0)));
3162                 tcg_gen_movi_tl(cpu_T[0], 0);
3163                 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_regs[reg].XMM_L(2)));
3164                 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_regs[reg].XMM_L(3)));
3165             } else {
3166                 rm = (modrm & 7) | REX_B(s);
3167                 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)),
3168                             offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)));
3169             }
3170             break;
3171         case 0x012: /* movlps */
3172         case 0x112: /* movlpd */
3173             if (mod != 3) {
3174                 gen_lea_modrm(env, s, modrm);
3175                 gen_ldq_env_A0(s, offsetof(CPUX86State,
3176                                            xmm_regs[reg].XMM_Q(0)));
3177             } else {
3178                 /* movhlps */
3179                 rm = (modrm & 7) | REX_B(s);
3180                 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)),
3181                             offsetof(CPUX86State,xmm_regs[rm].XMM_Q(1)));
3182             }
3183             break;
3184         case 0x212: /* movsldup */
3185             if (mod != 3) {
3186                 gen_lea_modrm(env, s, modrm);
3187                 gen_ldo_env_A0(s, offsetof(CPUX86State, xmm_regs[reg]));
3188             } else {
3189                 rm = (modrm & 7) | REX_B(s);
3190                 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)),
3191                             offsetof(CPUX86State,xmm_regs[rm].XMM_L(0)));
3192                 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(2)),
3193                             offsetof(CPUX86State,xmm_regs[rm].XMM_L(2)));
3194             }
3195             gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(1)),
3196                         offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)));
3197             gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(3)),
3198                         offsetof(CPUX86State,xmm_regs[reg].XMM_L(2)));
3199             break;
3200         case 0x312: /* movddup */
3201             if (mod != 3) {
3202                 gen_lea_modrm(env, s, modrm);
3203                 gen_ldq_env_A0(s, offsetof(CPUX86State,
3204                                            xmm_regs[reg].XMM_Q(0)));
3205             } else {
3206                 rm = (modrm & 7) | REX_B(s);
3207                 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)),
3208                             offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)));
3209             }
3210             gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)),
3211                         offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3212             break;
3213         case 0x016: /* movhps */
3214         case 0x116: /* movhpd */
3215             if (mod != 3) {
3216                 gen_lea_modrm(env, s, modrm);
3217                 gen_ldq_env_A0(s, offsetof(CPUX86State,
3218                                            xmm_regs[reg].XMM_Q(1)));
3219             } else {
3220                 /* movlhps */
3221                 rm = (modrm & 7) | REX_B(s);
3222                 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)),
3223                             offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)));
3224             }
3225             break;
3226         case 0x216: /* movshdup */
3227             if (mod != 3) {
3228                 gen_lea_modrm(env, s, modrm);
3229                 gen_ldo_env_A0(s, offsetof(CPUX86State, xmm_regs[reg]));
3230             } else {
3231                 rm = (modrm & 7) | REX_B(s);
3232                 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(1)),
3233                             offsetof(CPUX86State,xmm_regs[rm].XMM_L(1)));
3234                 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(3)),
3235                             offsetof(CPUX86State,xmm_regs[rm].XMM_L(3)));
3236             }
3237             gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)),
3238                         offsetof(CPUX86State,xmm_regs[reg].XMM_L(1)));
3239             gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(2)),
3240                         offsetof(CPUX86State,xmm_regs[reg].XMM_L(3)));
3241             break;
3242         case 0x178:
3243         case 0x378:
3244             {
3245                 int bit_index, field_length;
3246
3247                 if (b1 == 1 && reg != 0)
3248                     goto illegal_op;
3249                 field_length = cpu_ldub_code(env, s->pc++) & 0x3F;
3250                 bit_index = cpu_ldub_code(env, s->pc++) & 0x3F;
3251                 tcg_gen_addi_ptr(cpu_ptr0, cpu_env,
3252                     offsetof(CPUX86State,xmm_regs[reg]));
3253                 if (b1 == 1)
3254                     gen_helper_extrq_i(cpu_env, cpu_ptr0,
3255                                        tcg_const_i32(bit_index),
3256                                        tcg_const_i32(field_length));
3257                 else
3258                     gen_helper_insertq_i(cpu_env, cpu_ptr0,
3259                                          tcg_const_i32(bit_index),
3260                                          tcg_const_i32(field_length));
3261             }
3262             break;
3263         case 0x7e: /* movd ea, mm */
3264 #ifdef TARGET_X86_64
3265             if (s->dflag == MO_64) {
3266                 tcg_gen_ld_i64(cpu_T[0], cpu_env,
3267                                offsetof(CPUX86State,fpregs[reg].mmx));
3268                 gen_ldst_modrm(env, s, modrm, MO_64, OR_TMP0, 1);
3269             } else
3270 #endif
3271             {
3272                 tcg_gen_ld32u_tl(cpu_T[0], cpu_env,
3273                                  offsetof(CPUX86State,fpregs[reg].mmx.MMX_L(0)));
3274                 gen_ldst_modrm(env, s, modrm, MO_32, OR_TMP0, 1);
3275             }
3276             break;
3277         case 0x17e: /* movd ea, xmm */
3278 #ifdef TARGET_X86_64
3279             if (s->dflag == MO_64) {
3280                 tcg_gen_ld_i64(cpu_T[0], cpu_env,
3281                                offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3282                 gen_ldst_modrm(env, s, modrm, MO_64, OR_TMP0, 1);
3283             } else
3284 #endif
3285             {
3286                 tcg_gen_ld32u_tl(cpu_T[0], cpu_env,
3287                                  offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)));
3288                 gen_ldst_modrm(env, s, modrm, MO_32, OR_TMP0, 1);
3289             }
3290             break;
3291         case 0x27e: /* movq xmm, ea */
3292             if (mod != 3) {
3293                 gen_lea_modrm(env, s, modrm);
3294                 gen_ldq_env_A0(s, offsetof(CPUX86State,
3295                                            xmm_regs[reg].XMM_Q(0)));
3296             } else {
3297                 rm = (modrm & 7) | REX_B(s);
3298                 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)),
3299                             offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)));
3300             }
3301             gen_op_movq_env_0(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)));
3302             break;
3303         case 0x7f: /* movq ea, mm */
3304             if (mod != 3) {
3305                 gen_lea_modrm(env, s, modrm);
3306                 gen_stq_env_A0(s, offsetof(CPUX86State, fpregs[reg].mmx));
3307             } else {
3308                 rm = (modrm & 7);
3309                 gen_op_movq(offsetof(CPUX86State,fpregs[rm].mmx),
3310                             offsetof(CPUX86State,fpregs[reg].mmx));
3311             }
3312             break;
3313         case 0x011: /* movups */
3314         case 0x111: /* movupd */
3315         case 0x029: /* movaps */
3316         case 0x129: /* movapd */
3317         case 0x17f: /* movdqa ea, xmm */
3318         case 0x27f: /* movdqu ea, xmm */
3319             if (mod != 3) {
3320                 gen_lea_modrm(env, s, modrm);
3321                 gen_sto_env_A0(s, offsetof(CPUX86State, xmm_regs[reg]));
3322             } else {
3323                 rm = (modrm & 7) | REX_B(s);
3324                 gen_op_movo(offsetof(CPUX86State,xmm_regs[rm]),
3325                             offsetof(CPUX86State,xmm_regs[reg]));
3326             }
3327             break;
3328         case 0x211: /* movss ea, xmm */
3329             if (mod != 3) {
3330                 gen_lea_modrm(env, s, modrm);
3331                 tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)));
3332                 gen_op_st_v(s, MO_32, cpu_T[0], cpu_A0);
3333             } else {
3334                 rm = (modrm & 7) | REX_B(s);
3335                 gen_op_movl(offsetof(CPUX86State,xmm_regs[rm].XMM_L(0)),
3336                             offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)));
3337             }
3338             break;
3339         case 0x311: /* movsd ea, xmm */
3340             if (mod != 3) {
3341                 gen_lea_modrm(env, s, modrm);
3342                 gen_stq_env_A0(s, offsetof(CPUX86State,
3343                                            xmm_regs[reg].XMM_Q(0)));
3344             } else {
3345                 rm = (modrm & 7) | REX_B(s);
3346                 gen_op_movq(offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)),
3347                             offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3348             }
3349             break;
3350         case 0x013: /* movlps */
3351         case 0x113: /* movlpd */
3352             if (mod != 3) {
3353                 gen_lea_modrm(env, s, modrm);
3354                 gen_stq_env_A0(s, offsetof(CPUX86State,
3355                                            xmm_regs[reg].XMM_Q(0)));
3356             } else {
3357                 goto illegal_op;
3358             }
3359             break;
3360         case 0x017: /* movhps */
3361         case 0x117: /* movhpd */
3362             if (mod != 3) {
3363                 gen_lea_modrm(env, s, modrm);
3364                 gen_stq_env_A0(s, offsetof(CPUX86State,
3365                                            xmm_regs[reg].XMM_Q(1)));
3366             } else {
3367                 goto illegal_op;
3368             }
3369             break;
3370         case 0x71: /* shift mm, im */
3371         case 0x72:
3372         case 0x73:
3373         case 0x171: /* shift xmm, im */
3374         case 0x172:
3375         case 0x173:
3376             if (b1 >= 2) {
3377                 goto illegal_op;
3378             }
3379             val = cpu_ldub_code(env, s->pc++);
3380             if (is_xmm) {
3381                 tcg_gen_movi_tl(cpu_T[0], val);
3382                 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_t0.XMM_L(0)));
3383                 tcg_gen_movi_tl(cpu_T[0], 0);
3384                 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_t0.XMM_L(1)));
3385                 op1_offset = offsetof(CPUX86State,xmm_t0);
3386             } else {
3387                 tcg_gen_movi_tl(cpu_T[0], val);
3388                 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,mmx_t0.MMX_L(0)));
3389                 tcg_gen_movi_tl(cpu_T[0], 0);
3390                 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,mmx_t0.MMX_L(1)));
3391                 op1_offset = offsetof(CPUX86State,mmx_t0);
3392             }
3393             sse_fn_epp = sse_op_table2[((b - 1) & 3) * 8 +
3394                                        (((modrm >> 3)) & 7)][b1];
3395             if (!sse_fn_epp) {
3396                 goto illegal_op;
3397             }
3398             if (is_xmm) {
3399                 rm = (modrm & 7) | REX_B(s);
3400                 op2_offset = offsetof(CPUX86State,xmm_regs[rm]);
3401             } else {
3402                 rm = (modrm & 7);
3403                 op2_offset = offsetof(CPUX86State,fpregs[rm].mmx);
3404             }
3405             tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op2_offset);
3406             tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op1_offset);
3407             sse_fn_epp(cpu_env, cpu_ptr0, cpu_ptr1);
3408             break;
3409         case 0x050: /* movmskps */
3410             rm = (modrm & 7) | REX_B(s);
3411             tcg_gen_addi_ptr(cpu_ptr0, cpu_env,
3412                              offsetof(CPUX86State,xmm_regs[rm]));
3413             gen_helper_movmskps(cpu_tmp2_i32, cpu_env, cpu_ptr0);
3414             tcg_gen_extu_i32_tl(cpu_regs[reg], cpu_tmp2_i32);
3415             break;
3416         case 0x150: /* movmskpd */
3417             rm = (modrm & 7) | REX_B(s);
3418             tcg_gen_addi_ptr(cpu_ptr0, cpu_env,
3419                              offsetof(CPUX86State,xmm_regs[rm]));
3420             gen_helper_movmskpd(cpu_tmp2_i32, cpu_env, cpu_ptr0);
3421             tcg_gen_extu_i32_tl(cpu_regs[reg], cpu_tmp2_i32);
3422             break;
3423         case 0x02a: /* cvtpi2ps */
3424         case 0x12a: /* cvtpi2pd */
3425             gen_helper_enter_mmx(cpu_env);
3426             if (mod != 3) {
3427                 gen_lea_modrm(env, s, modrm);
3428                 op2_offset = offsetof(CPUX86State,mmx_t0);
3429                 gen_ldq_env_A0(s, op2_offset);
3430             } else {
3431                 rm = (modrm & 7);
3432                 op2_offset = offsetof(CPUX86State,fpregs[rm].mmx);
3433             }
3434             op1_offset = offsetof(CPUX86State,xmm_regs[reg]);
3435             tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
3436             tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
3437             switch(b >> 8) {
3438             case 0x0:
3439                 gen_helper_cvtpi2ps(cpu_env, cpu_ptr0, cpu_ptr1);
3440                 break;
3441             default:
3442             case 0x1:
3443                 gen_helper_cvtpi2pd(cpu_env, cpu_ptr0, cpu_ptr1);
3444                 break;
3445             }
3446             break;
3447         case 0x22a: /* cvtsi2ss */
3448         case 0x32a: /* cvtsi2sd */
3449             ot = mo_64_32(s->dflag);
3450             gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
3451             op1_offset = offsetof(CPUX86State,xmm_regs[reg]);
3452             tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
3453             if (ot == MO_32) {
3454                 SSEFunc_0_epi sse_fn_epi = sse_op_table3ai[(b >> 8) & 1];
3455                 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
3456                 sse_fn_epi(cpu_env, cpu_ptr0, cpu_tmp2_i32);
3457             } else {
3458 #ifdef TARGET_X86_64
3459                 SSEFunc_0_epl sse_fn_epl = sse_op_table3aq[(b >> 8) & 1];
3460                 sse_fn_epl(cpu_env, cpu_ptr0, cpu_T[0]);
3461 #else
3462                 goto illegal_op;
3463 #endif
3464             }
3465             break;
3466         case 0x02c: /* cvttps2pi */
3467         case 0x12c: /* cvttpd2pi */
3468         case 0x02d: /* cvtps2pi */
3469         case 0x12d: /* cvtpd2pi */
3470             gen_helper_enter_mmx(cpu_env);
3471             if (mod != 3) {
3472                 gen_lea_modrm(env, s, modrm);
3473                 op2_offset = offsetof(CPUX86State,xmm_t0);
3474                 gen_ldo_env_A0(s, op2_offset);
3475             } else {
3476                 rm = (modrm & 7) | REX_B(s);
3477                 op2_offset = offsetof(CPUX86State,xmm_regs[rm]);
3478             }
3479             op1_offset = offsetof(CPUX86State,fpregs[reg & 7].mmx);
3480             tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
3481             tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
3482             switch(b) {
3483             case 0x02c:
3484                 gen_helper_cvttps2pi(cpu_env, cpu_ptr0, cpu_ptr1);
3485                 break;
3486             case 0x12c:
3487                 gen_helper_cvttpd2pi(cpu_env, cpu_ptr0, cpu_ptr1);
3488                 break;
3489             case 0x02d:
3490                 gen_helper_cvtps2pi(cpu_env, cpu_ptr0, cpu_ptr1);
3491                 break;
3492             case 0x12d:
3493                 gen_helper_cvtpd2pi(cpu_env, cpu_ptr0, cpu_ptr1);
3494                 break;
3495             }
3496             break;
3497         case 0x22c: /* cvttss2si */
3498         case 0x32c: /* cvttsd2si */
3499         case 0x22d: /* cvtss2si */
3500         case 0x32d: /* cvtsd2si */
3501             ot = mo_64_32(s->dflag);
3502             if (mod != 3) {
3503                 gen_lea_modrm(env, s, modrm);
3504                 if ((b >> 8) & 1) {
3505                     gen_ldq_env_A0(s, offsetof(CPUX86State, xmm_t0.XMM_Q(0)));
3506                 } else {
3507                     gen_op_ld_v(s, MO_32, cpu_T[0], cpu_A0);
3508                     tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_t0.XMM_L(0)));
3509                 }
3510                 op2_offset = offsetof(CPUX86State,xmm_t0);
3511             } else {
3512                 rm = (modrm & 7) | REX_B(s);
3513                 op2_offset = offsetof(CPUX86State,xmm_regs[rm]);
3514             }
3515             tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op2_offset);
3516             if (ot == MO_32) {
3517                 SSEFunc_i_ep sse_fn_i_ep =
3518                     sse_op_table3bi[((b >> 7) & 2) | (b & 1)];
3519                 sse_fn_i_ep(cpu_tmp2_i32, cpu_env, cpu_ptr0);
3520                 tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
3521             } else {
3522 #ifdef TARGET_X86_64
3523                 SSEFunc_l_ep sse_fn_l_ep =
3524                     sse_op_table3bq[((b >> 7) & 2) | (b & 1)];
3525                 sse_fn_l_ep(cpu_T[0], cpu_env, cpu_ptr0);
3526 #else
3527                 goto illegal_op;
3528 #endif
3529             }
3530             gen_op_mov_reg_v(ot, reg, cpu_T[0]);
3531             break;
3532         case 0xc4: /* pinsrw */
3533         case 0x1c4:
3534             s->rip_offset = 1;
3535             gen_ldst_modrm(env, s, modrm, MO_16, OR_TMP0, 0);
3536             val = cpu_ldub_code(env, s->pc++);
3537             if (b1) {
3538                 val &= 7;
3539                 tcg_gen_st16_tl(cpu_T[0], cpu_env,
3540                                 offsetof(CPUX86State,xmm_regs[reg].XMM_W(val)));
3541             } else {
3542                 val &= 3;
3543                 tcg_gen_st16_tl(cpu_T[0], cpu_env,
3544                                 offsetof(CPUX86State,fpregs[reg].mmx.MMX_W(val)));
3545             }
3546             break;
3547         case 0xc5: /* pextrw */
3548         case 0x1c5:
3549             if (mod != 3)
3550                 goto illegal_op;
3551             ot = mo_64_32(s->dflag);
3552             val = cpu_ldub_code(env, s->pc++);
3553             if (b1) {
3554                 val &= 7;
3555                 rm = (modrm & 7) | REX_B(s);
3556                 tcg_gen_ld16u_tl(cpu_T[0], cpu_env,
3557                                  offsetof(CPUX86State,xmm_regs[rm].XMM_W(val)));
3558             } else {
3559                 val &= 3;
3560                 rm = (modrm & 7);
3561                 tcg_gen_ld16u_tl(cpu_T[0], cpu_env,
3562                                 offsetof(CPUX86State,fpregs[rm].mmx.MMX_W(val)));
3563             }
3564             reg = ((modrm >> 3) & 7) | rex_r;
3565             gen_op_mov_reg_v(ot, reg, cpu_T[0]);
3566             break;
3567         case 0x1d6: /* movq ea, xmm */
3568             if (mod != 3) {
3569                 gen_lea_modrm(env, s, modrm);
3570                 gen_stq_env_A0(s, offsetof(CPUX86State,
3571                                            xmm_regs[reg].XMM_Q(0)));
3572             } else {
3573                 rm = (modrm & 7) | REX_B(s);
3574                 gen_op_movq(offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)),
3575                             offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3576                 gen_op_movq_env_0(offsetof(CPUX86State,xmm_regs[rm].XMM_Q(1)));
3577             }
3578             break;
3579         case 0x2d6: /* movq2dq */
3580             gen_helper_enter_mmx(cpu_env);
3581             rm = (modrm & 7);
3582             gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)),
3583                         offsetof(CPUX86State,fpregs[rm].mmx));
3584             gen_op_movq_env_0(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)));
3585             break;
3586         case 0x3d6: /* movdq2q */
3587             gen_helper_enter_mmx(cpu_env);
3588             rm = (modrm & 7) | REX_B(s);
3589             gen_op_movq(offsetof(CPUX86State,fpregs[reg & 7].mmx),
3590                         offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)));
3591             break;
3592         case 0xd7: /* pmovmskb */
3593         case 0x1d7:
3594             if (mod != 3)
3595                 goto illegal_op;
3596             if (b1) {
3597                 rm = (modrm & 7) | REX_B(s);
3598                 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, offsetof(CPUX86State,xmm_regs[rm]));
3599                 gen_helper_pmovmskb_xmm(cpu_tmp2_i32, cpu_env, cpu_ptr0);
3600             } else {
3601                 rm = (modrm & 7);
3602                 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, offsetof(CPUX86State,fpregs[rm].mmx));
3603                 gen_helper_pmovmskb_mmx(cpu_tmp2_i32, cpu_env, cpu_ptr0);
3604             }
3605             reg = ((modrm >> 3) & 7) | rex_r;
3606             tcg_gen_extu_i32_tl(cpu_regs[reg], cpu_tmp2_i32);
3607             break;
3608
3609         case 0x138:
3610         case 0x038:
3611             b = modrm;
3612             if ((b & 0xf0) == 0xf0) {
3613                 goto do_0f_38_fx;
3614             }
3615             modrm = cpu_ldub_code(env, s->pc++);
3616             rm = modrm & 7;
3617             reg = ((modrm >> 3) & 7) | rex_r;
3618             mod = (modrm >> 6) & 3;
3619             if (b1 >= 2) {
3620                 goto illegal_op;
3621             }
3622
3623             sse_fn_epp = sse_op_table6[b].op[b1];
3624             if (!sse_fn_epp) {
3625                 goto illegal_op;
3626             }
3627             if (!(s->cpuid_ext_features & sse_op_table6[b].ext_mask))
3628                 goto illegal_op;
3629
3630             if (b1) {
3631                 op1_offset = offsetof(CPUX86State,xmm_regs[reg]);
3632                 if (mod == 3) {
3633                     op2_offset = offsetof(CPUX86State,xmm_regs[rm | REX_B(s)]);
3634                 } else {
3635                     op2_offset = offsetof(CPUX86State,xmm_t0);
3636                     gen_lea_modrm(env, s, modrm);
3637                     switch (b) {
3638                     case 0x20: case 0x30: /* pmovsxbw, pmovzxbw */
3639                     case 0x23: case 0x33: /* pmovsxwd, pmovzxwd */
3640                     case 0x25: case 0x35: /* pmovsxdq, pmovzxdq */
3641                         gen_ldq_env_A0(s, op2_offset +
3642                                         offsetof(XMMReg, XMM_Q(0)));
3643                         break;
3644                     case 0x21: case 0x31: /* pmovsxbd, pmovzxbd */
3645                     case 0x24: case 0x34: /* pmovsxwq, pmovzxwq */
3646                         tcg_gen_qemu_ld_i32(cpu_tmp2_i32, cpu_A0,
3647                                             s->mem_index, MO_LEUL);
3648                         tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, op2_offset +
3649                                         offsetof(XMMReg, XMM_L(0)));
3650                         break;
3651                     case 0x22: case 0x32: /* pmovsxbq, pmovzxbq */
3652                         tcg_gen_qemu_ld_tl(cpu_tmp0, cpu_A0,
3653                                            s->mem_index, MO_LEUW);
3654                         tcg_gen_st16_tl(cpu_tmp0, cpu_env, op2_offset +
3655                                         offsetof(XMMReg, XMM_W(0)));
3656                         break;
3657                     case 0x2a:            /* movntqda */
3658                         gen_ldo_env_A0(s, op1_offset);
3659                         return;
3660                     default:
3661                         gen_ldo_env_A0(s, op2_offset);
3662                     }
3663                 }
3664             } else {
3665                 op1_offset = offsetof(CPUX86State,fpregs[reg].mmx);
3666                 if (mod == 3) {
3667                     op2_offset = offsetof(CPUX86State,fpregs[rm].mmx);
3668                 } else {
3669                     op2_offset = offsetof(CPUX86State,mmx_t0);
3670                     gen_lea_modrm(env, s, modrm);
3671                     gen_ldq_env_A0(s, op2_offset);
3672                 }
3673             }
3674             if (sse_fn_epp == SSE_SPECIAL) {
3675                 goto illegal_op;
3676             }
3677
3678             tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
3679             tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
3680             sse_fn_epp(cpu_env, cpu_ptr0, cpu_ptr1);
3681
3682             if (b == 0x17) {
3683                 set_cc_op(s, CC_OP_EFLAGS);
3684             }
3685             break;
3686
3687         case 0x238:
3688         case 0x338:
3689         do_0f_38_fx:
3690             /* Various integer extensions at 0f 38 f[0-f].  */
3691             b = modrm | (b1 << 8);
3692             modrm = cpu_ldub_code(env, s->pc++);
3693             reg = ((modrm >> 3) & 7) | rex_r;
3694
3695             switch (b) {
3696             case 0x3f0: /* crc32 Gd,Eb */
3697             case 0x3f1: /* crc32 Gd,Ey */
3698             do_crc32:
3699                 if (!(s->cpuid_ext_features & CPUID_EXT_SSE42)) {
3700                     goto illegal_op;
3701                 }
3702                 if ((b & 0xff) == 0xf0) {
3703                     ot = MO_8;
3704                 } else if (s->dflag != MO_64) {
3705                     ot = (s->prefix & PREFIX_DATA ? MO_16 : MO_32);
3706                 } else {
3707                     ot = MO_64;
3708                 }
3709
3710                 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_regs[reg]);
3711                 gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
3712                 gen_helper_crc32(cpu_T[0], cpu_tmp2_i32,
3713                                  cpu_T[0], tcg_const_i32(8 << ot));
3714
3715                 ot = mo_64_32(s->dflag);
3716                 gen_op_mov_reg_v(ot, reg, cpu_T[0]);
3717                 break;
3718
3719             case 0x1f0: /* crc32 or movbe */
3720             case 0x1f1:
3721                 /* For these insns, the f3 prefix is supposed to have priority
3722                    over the 66 prefix, but that's not what we implement above
3723                    setting b1.  */
3724                 if (s->prefix & PREFIX_REPNZ) {
3725                     goto do_crc32;
3726                 }
3727                 /* FALLTHRU */
3728             case 0x0f0: /* movbe Gy,My */
3729             case 0x0f1: /* movbe My,Gy */
3730                 if (!(s->cpuid_ext_features & CPUID_EXT_MOVBE)) {
3731                     goto illegal_op;
3732                 }
3733                 if (s->dflag != MO_64) {
3734                     ot = (s->prefix & PREFIX_DATA ? MO_16 : MO_32);
3735                 } else {
3736                     ot = MO_64;
3737                 }
3738
3739                 gen_lea_modrm(env, s, modrm);
3740                 if ((b & 1) == 0) {
3741                     tcg_gen_qemu_ld_tl(cpu_T[0], cpu_A0,
3742                                        s->mem_index, ot | MO_BE);
3743                     gen_op_mov_reg_v(ot, reg, cpu_T[0]);
3744                 } else {
3745                     tcg_gen_qemu_st_tl(cpu_regs[reg], cpu_A0,
3746                                        s->mem_index, ot | MO_BE);
3747                 }
3748                 break;
3749
3750             case 0x0f2: /* andn Gy, By, Ey */
3751                 if (!(s->cpuid_7_0_ebx_features & CPUID_7_0_EBX_BMI1)
3752                     || !(s->prefix & PREFIX_VEX)
3753                     || s->vex_l != 0) {
3754                     goto illegal_op;
3755                 }
3756                 ot = mo_64_32(s->dflag);
3757                 gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
3758                 tcg_gen_andc_tl(cpu_T[0], cpu_regs[s->vex_v], cpu_T[0]);
3759                 gen_op_mov_reg_v(ot, reg, cpu_T[0]);
3760                 gen_op_update1_cc();
3761                 set_cc_op(s, CC_OP_LOGICB + ot);
3762                 break;
3763
3764             case 0x0f7: /* bextr Gy, Ey, By */
3765                 if (!(s->cpuid_7_0_ebx_features & CPUID_7_0_EBX_BMI1)
3766                     || !(s->prefix & PREFIX_VEX)
3767                     || s->vex_l != 0) {
3768                     goto illegal_op;
3769                 }
3770                 ot = mo_64_32(s->dflag);
3771                 {
3772                     TCGv bound, zero;
3773
3774                     gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
3775                     /* Extract START, and shift the operand.
3776                        Shifts larger than operand size get zeros.  */
3777                     tcg_gen_ext8u_tl(cpu_A0, cpu_regs[s->vex_v]);
3778                     tcg_gen_shr_tl(cpu_T[0], cpu_T[0], cpu_A0);
3779
3780                     bound = tcg_const_tl(ot == MO_64 ? 63 : 31);
3781                     zero = tcg_const_tl(0);
3782                     tcg_gen_movcond_tl(TCG_COND_LEU, cpu_T[0], cpu_A0, bound,
3783                                        cpu_T[0], zero);
3784                     tcg_temp_free(zero);
3785
3786                     /* Extract the LEN into a mask.  Lengths larger than
3787                        operand size get all ones.  */
3788                     tcg_gen_shri_tl(cpu_A0, cpu_regs[s->vex_v], 8);
3789                     tcg_gen_ext8u_tl(cpu_A0, cpu_A0);
3790                     tcg_gen_movcond_tl(TCG_COND_LEU, cpu_A0, cpu_A0, bound,
3791                                        cpu_A0, bound);
3792                     tcg_temp_free(bound);
3793                     tcg_gen_movi_tl(cpu_T[1], 1);
3794                     tcg_gen_shl_tl(cpu_T[1], cpu_T[1], cpu_A0);
3795                     tcg_gen_subi_tl(cpu_T[1], cpu_T[1], 1);
3796                     tcg_gen_and_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
3797
3798                     gen_op_mov_reg_v(ot, reg, cpu_T[0]);
3799                     gen_op_update1_cc();
3800                     set_cc_op(s, CC_OP_LOGICB + ot);
3801                 }
3802                 break;
3803
3804             case 0x0f5: /* bzhi Gy, Ey, By */
3805                 if (!(s->cpuid_7_0_ebx_features & CPUID_7_0_EBX_BMI2)
3806                     || !(s->prefix & PREFIX_VEX)
3807                     || s->vex_l != 0) {
3808                     goto illegal_op;
3809                 }
3810                 ot = mo_64_32(s->dflag);
3811                 gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
3812                 tcg_gen_ext8u_tl(cpu_T[1], cpu_regs[s->vex_v]);
3813                 {
3814                     TCGv bound = tcg_const_tl(ot == MO_64 ? 63 : 31);
3815                     /* Note that since we're using BMILG (in order to get O
3816                        cleared) we need to store the inverse into C.  */
3817                     tcg_gen_setcond_tl(TCG_COND_LT, cpu_cc_src,
3818                                        cpu_T[1], bound);
3819                     tcg_gen_movcond_tl(TCG_COND_GT, cpu_T[1], cpu_T[1],
3820                                        bound, bound, cpu_T[1]);
3821                     tcg_temp_free(bound);
3822                 }
3823                 tcg_gen_movi_tl(cpu_A0, -1);
3824                 tcg_gen_shl_tl(cpu_A0, cpu_A0, cpu_T[1]);
3825                 tcg_gen_andc_tl(cpu_T[0], cpu_T[0], cpu_A0);
3826                 gen_op_mov_reg_v(ot, reg, cpu_T[0]);
3827                 gen_op_update1_cc();
3828                 set_cc_op(s, CC_OP_BMILGB + ot);
3829                 break;
3830
3831             case 0x3f6: /* mulx By, Gy, rdx, Ey */
3832                 if (!(s->cpuid_7_0_ebx_features & CPUID_7_0_EBX_BMI2)
3833                     || !(s->prefix & PREFIX_VEX)
3834                     || s->vex_l != 0) {
3835                     goto illegal_op;
3836                 }
3837                 ot = mo_64_32(s->dflag);
3838                 gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
3839                 switch (ot) {
3840                 default:
3841                     tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
3842                     tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_regs[R_EDX]);
3843                     tcg_gen_mulu2_i32(cpu_tmp2_i32, cpu_tmp3_i32,
3844                                       cpu_tmp2_i32, cpu_tmp3_i32);
3845                     tcg_gen_extu_i32_tl(cpu_regs[s->vex_v], cpu_tmp2_i32);
3846                     tcg_gen_extu_i32_tl(cpu_regs[reg], cpu_tmp3_i32);
3847                     break;
3848 #ifdef TARGET_X86_64
3849                 case MO_64:
3850                     tcg_gen_mulu2_i64(cpu_regs[s->vex_v], cpu_regs[reg],
3851                                       cpu_T[0], cpu_regs[R_EDX]);
3852                     break;
3853 #endif
3854                 }
3855                 break;
3856
3857             case 0x3f5: /* pdep Gy, By, Ey */
3858                 if (!(s->cpuid_7_0_ebx_features & CPUID_7_0_EBX_BMI2)
3859                     || !(s->prefix & PREFIX_VEX)
3860                     || s->vex_l != 0) {
3861                     goto illegal_op;
3862                 }
3863                 ot = mo_64_32(s->dflag);
3864                 gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
3865                 /* Note that by zero-extending the mask operand, we
3866                    automatically handle zero-extending the result.  */
3867                 if (ot == MO_64) {
3868                     tcg_gen_mov_tl(cpu_T[1], cpu_regs[s->vex_v]);
3869                 } else {
3870                     tcg_gen_ext32u_tl(cpu_T[1], cpu_regs[s->vex_v]);
3871                 }
3872                 gen_helper_pdep(cpu_regs[reg], cpu_T[0], cpu_T[1]);
3873                 break;
3874
3875             case 0x2f5: /* pext Gy, By, Ey */
3876                 if (!(s->cpuid_7_0_ebx_features & CPUID_7_0_EBX_BMI2)
3877                     || !(s->prefix & PREFIX_VEX)
3878                     || s->vex_l != 0) {
3879                     goto illegal_op;
3880                 }
3881                 ot = mo_64_32(s->dflag);
3882                 gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
3883                 /* Note that by zero-extending the mask operand, we
3884                    automatically handle zero-extending the result.  */
3885                 if (ot == MO_64) {
3886                     tcg_gen_mov_tl(cpu_T[1], cpu_regs[s->vex_v]);
3887                 } else {
3888                     tcg_gen_ext32u_tl(cpu_T[1], cpu_regs[s->vex_v]);
3889                 }
3890                 gen_helper_pext(cpu_regs[reg], cpu_T[0], cpu_T[1]);
3891                 break;
3892
3893             case 0x1f6: /* adcx Gy, Ey */
3894             case 0x2f6: /* adox Gy, Ey */
3895                 if (!(s->cpuid_7_0_ebx_features & CPUID_7_0_EBX_ADX)) {
3896                     goto illegal_op;
3897                 } else {
3898                     TCGv carry_in, carry_out, zero;
3899                     int end_op;
3900
3901                     ot = mo_64_32(s->dflag);
3902                     gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
3903
3904                     /* Re-use the carry-out from a previous round.  */
3905                     TCGV_UNUSED(carry_in);
3906                     carry_out = (b == 0x1f6 ? cpu_cc_dst : cpu_cc_src2);
3907                     switch (s->cc_op) {
3908                     case CC_OP_ADCX:
3909                         if (b == 0x1f6) {
3910                             carry_in = cpu_cc_dst;
3911                             end_op = CC_OP_ADCX;
3912                         } else {
3913                             end_op = CC_OP_ADCOX;
3914                         }
3915                         break;
3916                     case CC_OP_ADOX:
3917                         if (b == 0x1f6) {
3918                             end_op = CC_OP_ADCOX;
3919                         } else {
3920                             carry_in = cpu_cc_src2;
3921                             end_op = CC_OP_ADOX;
3922                         }
3923                         break;
3924                     case CC_OP_ADCOX:
3925                         end_op = CC_OP_ADCOX;
3926                         carry_in = carry_out;
3927                         break;
3928                     default:
3929                         end_op = (b == 0x1f6 ? CC_OP_ADCX : CC_OP_ADOX);
3930                         break;
3931                     }
3932                     /* If we can't reuse carry-out, get it out of EFLAGS.  */
3933                     if (TCGV_IS_UNUSED(carry_in)) {
3934                         if (s->cc_op != CC_OP_ADCX && s->cc_op != CC_OP_ADOX) {
3935                             gen_compute_eflags(s);
3936                         }
3937                         carry_in = cpu_tmp0;
3938                         tcg_gen_shri_tl(carry_in, cpu_cc_src,
3939                                         ctz32(b == 0x1f6 ? CC_C : CC_O));
3940                         tcg_gen_andi_tl(carry_in, carry_in, 1);
3941                     }
3942
3943                     switch (ot) {
3944 #ifdef TARGET_X86_64
3945                     case MO_32:
3946                         /* If we know TL is 64-bit, and we want a 32-bit
3947                            result, just do everything in 64-bit arithmetic.  */
3948                         tcg_gen_ext32u_i64(cpu_regs[reg], cpu_regs[reg]);
3949                         tcg_gen_ext32u_i64(cpu_T[0], cpu_T[0]);
3950                         tcg_gen_add_i64(cpu_T[0], cpu_T[0], cpu_regs[reg]);
3951                         tcg_gen_add_i64(cpu_T[0], cpu_T[0], carry_in);
3952                         tcg_gen_ext32u_i64(cpu_regs[reg], cpu_T[0]);
3953                         tcg_gen_shri_i64(carry_out, cpu_T[0], 32);
3954                         break;
3955 #endif
3956                     default:
3957                         /* Otherwise compute the carry-out in two steps.  */
3958                         zero = tcg_const_tl(0);
3959                         tcg_gen_add2_tl(cpu_T[0], carry_out,
3960                                         cpu_T[0], zero,
3961                                         carry_in, zero);
3962                         tcg_gen_add2_tl(cpu_regs[reg], carry_out,
3963                                         cpu_regs[reg], carry_out,
3964                                         cpu_T[0], zero);
3965                         tcg_temp_free(zero);
3966                         break;
3967                     }
3968                     set_cc_op(s, end_op);
3969                 }
3970                 break;
3971
3972             case 0x1f7: /* shlx Gy, Ey, By */
3973             case 0x2f7: /* sarx Gy, Ey, By */
3974             case 0x3f7: /* shrx Gy, Ey, By */
3975                 if (!(s->cpuid_7_0_ebx_features & CPUID_7_0_EBX_BMI2)
3976                     || !(s->prefix & PREFIX_VEX)
3977                     || s->vex_l != 0) {
3978                     goto illegal_op;
3979                 }
3980                 ot = mo_64_32(s->dflag);
3981                 gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
3982                 if (ot == MO_64) {
3983                     tcg_gen_andi_tl(cpu_T[1], cpu_regs[s->vex_v], 63);
3984                 } else {
3985                     tcg_gen_andi_tl(cpu_T[1], cpu_regs[s->vex_v], 31);
3986                 }
3987                 if (b == 0x1f7) {
3988                     tcg_gen_shl_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
3989                 } else if (b == 0x2f7) {
3990                     if (ot != MO_64) {
3991                         tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
3992                     }
3993                     tcg_gen_sar_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
3994                 } else {
3995                     if (ot != MO_64) {
3996                         tcg_gen_ext32u_tl(cpu_T[0], cpu_T[0]);
3997                     }
3998                     tcg_gen_shr_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
3999                 }
4000                 gen_op_mov_reg_v(ot, reg, cpu_T[0]);
4001                 break;
4002
4003             case 0x0f3:
4004             case 0x1f3:
4005             case 0x2f3:
4006             case 0x3f3: /* Group 17 */
4007                 if (!(s->cpuid_7_0_ebx_features & CPUID_7_0_EBX_BMI1)
4008                     || !(s->prefix & PREFIX_VEX)
4009                     || s->vex_l != 0) {
4010                     goto illegal_op;
4011                 }
4012                 ot = mo_64_32(s->dflag);
4013                 gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
4014
4015                 switch (reg & 7) {
4016                 case 1: /* blsr By,Ey */
4017                     tcg_gen_neg_tl(cpu_T[1], cpu_T[0]);
4018                     tcg_gen_and_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
4019                     gen_op_mov_reg_v(ot, s->vex_v, cpu_T[0]);
4020                     gen_op_update2_cc();
4021                     set_cc_op(s, CC_OP_BMILGB + ot);
4022                     break;
4023
4024                 case 2: /* blsmsk By,Ey */
4025                     tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
4026                     tcg_gen_subi_tl(cpu_T[0], cpu_T[0], 1);
4027                     tcg_gen_xor_tl(cpu_T[0], cpu_T[0], cpu_cc_src);
4028                     tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4029                     set_cc_op(s, CC_OP_BMILGB + ot);
4030                     break;
4031
4032                 case 3: /* blsi By, Ey */
4033                     tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
4034                     tcg_gen_subi_tl(cpu_T[0], cpu_T[0], 1);
4035                     tcg_gen_and_tl(cpu_T[0], cpu_T[0], cpu_cc_src);
4036                     tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4037                     set_cc_op(s, CC_OP_BMILGB + ot);
4038                     break;
4039
4040                 default:
4041                     goto illegal_op;
4042                 }
4043                 break;
4044
4045             default:
4046                 goto illegal_op;
4047             }
4048             break;
4049
4050         case 0x03a:
4051         case 0x13a:
4052             b = modrm;
4053             modrm = cpu_ldub_code(env, s->pc++);
4054             rm = modrm & 7;
4055             reg = ((modrm >> 3) & 7) | rex_r;
4056             mod = (modrm >> 6) & 3;
4057             if (b1 >= 2) {
4058                 goto illegal_op;
4059             }
4060
4061             sse_fn_eppi = sse_op_table7[b].op[b1];
4062             if (!sse_fn_eppi) {
4063                 goto illegal_op;
4064             }
4065             if (!(s->cpuid_ext_features & sse_op_table7[b].ext_mask))
4066                 goto illegal_op;
4067
4068             if (sse_fn_eppi == SSE_SPECIAL) {
4069                 ot = mo_64_32(s->dflag);
4070                 rm = (modrm & 7) | REX_B(s);
4071                 if (mod != 3)
4072                     gen_lea_modrm(env, s, modrm);
4073                 reg = ((modrm >> 3) & 7) | rex_r;
4074                 val = cpu_ldub_code(env, s->pc++);
4075                 switch (b) {
4076                 case 0x14: /* pextrb */
4077                     tcg_gen_ld8u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,
4078                                             xmm_regs[reg].XMM_B(val & 15)));
4079                     if (mod == 3) {
4080                         gen_op_mov_reg_v(ot, rm, cpu_T[0]);
4081                     } else {
4082                         tcg_gen_qemu_st_tl(cpu_T[0], cpu_A0,
4083                                            s->mem_index, MO_UB);
4084                     }
4085                     break;
4086                 case 0x15: /* pextrw */
4087                     tcg_gen_ld16u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,
4088                                             xmm_regs[reg].XMM_W(val & 7)));
4089                     if (mod == 3) {
4090                         gen_op_mov_reg_v(ot, rm, cpu_T[0]);
4091                     } else {
4092                         tcg_gen_qemu_st_tl(cpu_T[0], cpu_A0,
4093                                            s->mem_index, MO_LEUW);
4094                     }
4095                     break;
4096                 case 0x16:
4097                     if (ot == MO_32) { /* pextrd */
4098                         tcg_gen_ld_i32(cpu_tmp2_i32, cpu_env,
4099                                         offsetof(CPUX86State,
4100                                                 xmm_regs[reg].XMM_L(val & 3)));
4101                         if (mod == 3) {
4102                             tcg_gen_extu_i32_tl(cpu_regs[rm], cpu_tmp2_i32);
4103                         } else {
4104                             tcg_gen_qemu_st_i32(cpu_tmp2_i32, cpu_A0,
4105                                                 s->mem_index, MO_LEUL);
4106                         }
4107                     } else { /* pextrq */
4108 #ifdef TARGET_X86_64
4109                         tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env,
4110                                         offsetof(CPUX86State,
4111                                                 xmm_regs[reg].XMM_Q(val & 1)));
4112                         if (mod == 3) {
4113                             tcg_gen_mov_i64(cpu_regs[rm], cpu_tmp1_i64);
4114                         } else {
4115                             tcg_gen_qemu_st_i64(cpu_tmp1_i64, cpu_A0,
4116                                                 s->mem_index, MO_LEQ);
4117                         }
4118 #else
4119                         goto illegal_op;
4120 #endif
4121                     }
4122                     break;
4123                 case 0x17: /* extractps */
4124                     tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,
4125                                             xmm_regs[reg].XMM_L(val & 3)));
4126                     if (mod == 3) {
4127                         gen_op_mov_reg_v(ot, rm, cpu_T[0]);
4128                     } else {
4129                         tcg_gen_qemu_st_tl(cpu_T[0], cpu_A0,
4130                                            s->mem_index, MO_LEUL);
4131                     }
4132                     break;
4133                 case 0x20: /* pinsrb */
4134                     if (mod == 3) {
4135                         gen_op_mov_v_reg(MO_32, cpu_T[0], rm);
4136                     } else {
4137                         tcg_gen_qemu_ld_tl(cpu_T[0], cpu_A0,
4138                                            s->mem_index, MO_UB);
4139                     }
4140                     tcg_gen_st8_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,
4141                                             xmm_regs[reg].XMM_B(val & 15)));
4142                     break;
4143                 case 0x21: /* insertps */
4144                     if (mod == 3) {
4145                         tcg_gen_ld_i32(cpu_tmp2_i32, cpu_env,
4146                                         offsetof(CPUX86State,xmm_regs[rm]
4147                                                 .XMM_L((val >> 6) & 3)));
4148                     } else {
4149                         tcg_gen_qemu_ld_i32(cpu_tmp2_i32, cpu_A0,
4150                                             s->mem_index, MO_LEUL);
4151                     }
4152                     tcg_gen_st_i32(cpu_tmp2_i32, cpu_env,
4153                                     offsetof(CPUX86State,xmm_regs[reg]
4154                                             .XMM_L((val >> 4) & 3)));
4155                     if ((val >> 0) & 1)
4156                         tcg_gen_st_i32(tcg_const_i32(0 /*float32_zero*/),
4157                                         cpu_env, offsetof(CPUX86State,
4158                                                 xmm_regs[reg].XMM_L(0)));
4159                     if ((val >> 1) & 1)
4160                         tcg_gen_st_i32(tcg_const_i32(0 /*float32_zero*/),
4161                                         cpu_env, offsetof(CPUX86State,
4162                                                 xmm_regs[reg].XMM_L(1)));
4163                     if ((val >> 2) & 1)
4164                         tcg_gen_st_i32(tcg_const_i32(0 /*float32_zero*/),
4165                                         cpu_env, offsetof(CPUX86State,
4166                                                 xmm_regs[reg].XMM_L(2)));
4167                     if ((val >> 3) & 1)
4168                         tcg_gen_st_i32(tcg_const_i32(0 /*float32_zero*/),
4169                                         cpu_env, offsetof(CPUX86State,
4170                                                 xmm_regs[reg].XMM_L(3)));
4171                     break;
4172                 case 0x22:
4173                     if (ot == MO_32) { /* pinsrd */
4174                         if (mod == 3) {
4175                             tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_regs[rm]);
4176                         } else {
4177                             tcg_gen_qemu_ld_i32(cpu_tmp2_i32, cpu_A0,
4178                                                 s->mem_index, MO_LEUL);
4179                         }
4180                         tcg_gen_st_i32(cpu_tmp2_i32, cpu_env,
4181                                         offsetof(CPUX86State,
4182                                                 xmm_regs[reg].XMM_L(val & 3)));
4183                     } else { /* pinsrq */
4184 #ifdef TARGET_X86_64
4185                         if (mod == 3) {
4186                             gen_op_mov_v_reg(ot, cpu_tmp1_i64, rm);
4187                         } else {
4188                             tcg_gen_qemu_ld_i64(cpu_tmp1_i64, cpu_A0,
4189                                                 s->mem_index, MO_LEQ);
4190                         }
4191                         tcg_gen_st_i64(cpu_tmp1_i64, cpu_env,
4192                                         offsetof(CPUX86State,
4193                                                 xmm_regs[reg].XMM_Q(val & 1)));
4194 #else
4195                         goto illegal_op;
4196 #endif
4197                     }
4198                     break;
4199                 }
4200                 return;
4201             }
4202
4203             if (b1) {
4204                 op1_offset = offsetof(CPUX86State,xmm_regs[reg]);
4205                 if (mod == 3) {
4206                     op2_offset = offsetof(CPUX86State,xmm_regs[rm | REX_B(s)]);
4207                 } else {
4208                     op2_offset = offsetof(CPUX86State,xmm_t0);
4209                     gen_lea_modrm(env, s, modrm);
4210                     gen_ldo_env_A0(s, op2_offset);
4211                 }
4212             } else {
4213                 op1_offset = offsetof(CPUX86State,fpregs[reg].mmx);
4214                 if (mod == 3) {
4215                     op2_offset = offsetof(CPUX86State,fpregs[rm].mmx);
4216                 } else {
4217                     op2_offset = offsetof(CPUX86State,mmx_t0);
4218                     gen_lea_modrm(env, s, modrm);
4219                     gen_ldq_env_A0(s, op2_offset);
4220                 }
4221             }
4222             val = cpu_ldub_code(env, s->pc++);
4223
4224             if ((b & 0xfc) == 0x60) { /* pcmpXstrX */
4225                 set_cc_op(s, CC_OP_EFLAGS);
4226
4227                 if (s->dflag == MO_64) {
4228                     /* The helper must use entire 64-bit gp registers */
4229                     val |= 1 << 8;
4230                 }
4231             }
4232
4233             tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
4234             tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
4235             sse_fn_eppi(cpu_env, cpu_ptr0, cpu_ptr1, tcg_const_i32(val));
4236             break;
4237
4238         case 0x33a:
4239             /* Various integer extensions at 0f 3a f[0-f].  */
4240             b = modrm | (b1 << 8);
4241             modrm = cpu_ldub_code(env, s->pc++);
4242             reg = ((modrm >> 3) & 7) | rex_r;
4243
4244             switch (b) {
4245             case 0x3f0: /* rorx Gy,Ey, Ib */
4246                 if (!(s->cpuid_7_0_ebx_features & CPUID_7_0_EBX_BMI2)
4247                     || !(s->prefix & PREFIX_VEX)
4248                     || s->vex_l != 0) {
4249                     goto illegal_op;
4250                 }
4251                 ot = mo_64_32(s->dflag);
4252                 gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
4253                 b = cpu_ldub_code(env, s->pc++);
4254                 if (ot == MO_64) {
4255                     tcg_gen_rotri_tl(cpu_T[0], cpu_T[0], b & 63);
4256                 } else {
4257                     tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
4258                     tcg_gen_rotri_i32(cpu_tmp2_i32, cpu_tmp2_i32, b & 31);
4259                     tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
4260                 }
4261                 gen_op_mov_reg_v(ot, reg, cpu_T[0]);
4262                 break;
4263
4264             default:
4265                 goto illegal_op;
4266             }
4267             break;
4268
4269         default:
4270             goto illegal_op;
4271         }
4272     } else {
4273         /* generic MMX or SSE operation */
4274         switch(b) {
4275         case 0x70: /* pshufx insn */
4276         case 0xc6: /* pshufx insn */
4277         case 0xc2: /* compare insns */
4278             s->rip_offset = 1;
4279             break;
4280         default:
4281             break;
4282         }
4283         if (is_xmm) {
4284             op1_offset = offsetof(CPUX86State,xmm_regs[reg]);
4285             if (mod != 3) {
4286                 int sz = 4;
4287
4288                 gen_lea_modrm(env, s, modrm);
4289                 op2_offset = offsetof(CPUX86State,xmm_t0);
4290
4291                 switch (b) {
4292                 case 0x50 ... 0x5a:
4293                 case 0x5c ... 0x5f:
4294                 case 0xc2:
4295                     /* Most sse scalar operations.  */
4296                     if (b1 == 2) {
4297                         sz = 2;
4298                     } else if (b1 == 3) {
4299                         sz = 3;
4300                     }
4301                     break;
4302
4303                 case 0x2e:  /* ucomis[sd] */
4304                 case 0x2f:  /* comis[sd] */
4305                     if (b1 == 0) {
4306                         sz = 2;
4307                     } else {
4308                         sz = 3;
4309                     }
4310                     break;
4311                 }
4312
4313                 switch (sz) {
4314                 case 2:
4315                     /* 32 bit access */
4316                     gen_op_ld_v(s, MO_32, cpu_T[0], cpu_A0);
4317                     tcg_gen_st32_tl(cpu_T[0], cpu_env,
4318                                     offsetof(CPUX86State,xmm_t0.XMM_L(0)));
4319                     break;
4320                 case 3:
4321                     /* 64 bit access */
4322                     gen_ldq_env_A0(s, offsetof(CPUX86State, xmm_t0.XMM_D(0)));
4323                     break;
4324                 default:
4325                     /* 128 bit access */
4326                     gen_ldo_env_A0(s, op2_offset);
4327                     break;
4328                 }
4329             } else {
4330                 rm = (modrm & 7) | REX_B(s);
4331                 op2_offset = offsetof(CPUX86State,xmm_regs[rm]);
4332             }
4333         } else {
4334             op1_offset = offsetof(CPUX86State,fpregs[reg].mmx);
4335             if (mod != 3) {
4336                 gen_lea_modrm(env, s, modrm);
4337                 op2_offset = offsetof(CPUX86State,mmx_t0);
4338                 gen_ldq_env_A0(s, op2_offset);
4339             } else {
4340                 rm = (modrm & 7);
4341                 op2_offset = offsetof(CPUX86State,fpregs[rm].mmx);
4342             }
4343         }
4344         switch(b) {
4345         case 0x0f: /* 3DNow! data insns */
4346             if (!(s->cpuid_ext2_features & CPUID_EXT2_3DNOW))
4347                 goto illegal_op;
4348             val = cpu_ldub_code(env, s->pc++);
4349             sse_fn_epp = sse_op_table5[val];
4350             if (!sse_fn_epp) {
4351                 goto illegal_op;
4352             }
4353             tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
4354             tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
4355             sse_fn_epp(cpu_env, cpu_ptr0, cpu_ptr1);
4356             break;
4357         case 0x70: /* pshufx insn */
4358         case 0xc6: /* pshufx insn */
4359             val = cpu_ldub_code(env, s->pc++);
4360             tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
4361             tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
4362             /* XXX: introduce a new table? */
4363             sse_fn_ppi = (SSEFunc_0_ppi)sse_fn_epp;
4364             sse_fn_ppi(cpu_ptr0, cpu_ptr1, tcg_const_i32(val));
4365             break;
4366         case 0xc2:
4367             /* compare insns */
4368             val = cpu_ldub_code(env, s->pc++);
4369             if (val >= 8)
4370                 goto illegal_op;
4371             sse_fn_epp = sse_op_table4[val][b1];
4372
4373             tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
4374             tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
4375             sse_fn_epp(cpu_env, cpu_ptr0, cpu_ptr1);
4376             break;
4377         case 0xf7:
4378             /* maskmov : we must prepare A0 */
4379             if (mod != 3)
4380                 goto illegal_op;
4381             tcg_gen_mov_tl(cpu_A0, cpu_regs[R_EDI]);
4382             gen_extu(s->aflag, cpu_A0);
4383             gen_add_A0_ds_seg(s);
4384
4385             tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
4386             tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
4387             /* XXX: introduce a new table? */
4388             sse_fn_eppt = (SSEFunc_0_eppt)sse_fn_epp;
4389             sse_fn_eppt(cpu_env, cpu_ptr0, cpu_ptr1, cpu_A0);
4390             break;
4391         default:
4392             tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
4393             tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
4394             sse_fn_epp(cpu_env, cpu_ptr0, cpu_ptr1);
4395             break;
4396         }
4397         if (b == 0x2e || b == 0x2f) {
4398             set_cc_op(s, CC_OP_EFLAGS);
4399         }
4400     }
4401 }
4402
4403 /* convert one instruction. s->is_jmp is set if the translation must
4404    be stopped. Return the next pc value */
4405 static target_ulong disas_insn(CPUX86State *env, DisasContext *s,
4406                                target_ulong pc_start)
4407 {
4408     int b, prefixes;
4409     int shift;
4410     TCGMemOp ot, aflag, dflag;
4411     int modrm, reg, rm, mod, op, opreg, val;
4412     target_ulong next_eip, tval;
4413     int rex_w, rex_r;
4414
4415     if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP | CPU_LOG_TB_OP_OPT))) {
4416         tcg_gen_debug_insn_start(pc_start);
4417     }
4418     s->pc = pc_start;
4419     prefixes = 0;
4420     s->override = -1;
4421     rex_w = -1;
4422     rex_r = 0;
4423 #ifdef TARGET_X86_64
4424     s->rex_x = 0;
4425     s->rex_b = 0;
4426     x86_64_hregs = 0;
4427 #endif
4428     s->rip_offset = 0; /* for relative ip address */
4429     s->vex_l = 0;
4430     s->vex_v = 0;
4431  next_byte:
4432     b = cpu_ldub_code(env, s->pc);
4433     s->pc++;
4434     /* Collect prefixes.  */
4435     switch (b) {
4436     case 0xf3:
4437         prefixes |= PREFIX_REPZ;
4438         goto next_byte;
4439     case 0xf2:
4440         prefixes |= PREFIX_REPNZ;
4441         goto next_byte;
4442     case 0xf0:
4443         prefixes |= PREFIX_LOCK;
4444         goto next_byte;
4445     case 0x2e:
4446         s->override = R_CS;
4447         goto next_byte;
4448     case 0x36:
4449         s->override = R_SS;
4450         goto next_byte;
4451     case 0x3e:
4452         s->override = R_DS;
4453         goto next_byte;
4454     case 0x26:
4455         s->override = R_ES;
4456         goto next_byte;
4457     case 0x64:
4458         s->override = R_FS;
4459         goto next_byte;
4460     case 0x65:
4461         s->override = R_GS;
4462         goto next_byte;
4463     case 0x66:
4464         prefixes |= PREFIX_DATA;
4465         goto next_byte;
4466     case 0x67:
4467         prefixes |= PREFIX_ADR;
4468         goto next_byte;
4469 #ifdef TARGET_X86_64
4470     case 0x40 ... 0x4f:
4471         if (CODE64(s)) {
4472             /* REX prefix */
4473             rex_w = (b >> 3) & 1;
4474             rex_r = (b & 0x4) << 1;
4475             s->rex_x = (b & 0x2) << 2;
4476             REX_B(s) = (b & 0x1) << 3;
4477             x86_64_hregs = 1; /* select uniform byte register addressing */
4478             goto next_byte;
4479         }
4480         break;
4481 #endif
4482     case 0xc5: /* 2-byte VEX */
4483     case 0xc4: /* 3-byte VEX */
4484         /* VEX prefixes cannot be used except in 32-bit mode.
4485            Otherwise the instruction is LES or LDS.  */
4486         if (s->code32 && !s->vm86) {
4487             static const int pp_prefix[4] = {
4488                 0, PREFIX_DATA, PREFIX_REPZ, PREFIX_REPNZ
4489             };
4490             int vex3, vex2 = cpu_ldub_code(env, s->pc);
4491
4492             if (!CODE64(s) && (vex2 & 0xc0) != 0xc0) {
4493                 /* 4.1.4.6: In 32-bit mode, bits [7:6] must be 11b,
4494                    otherwise the instruction is LES or LDS.  */
4495                 break;
4496             }
4497             s->pc++;
4498
4499             /* 4.1.1-4.1.3: No preceding lock, 66, f2, f3, or rex prefixes. */
4500             if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ
4501                             | PREFIX_LOCK | PREFIX_DATA)) {
4502                 goto illegal_op;
4503             }
4504 #ifdef TARGET_X86_64
4505             if (x86_64_hregs) {
4506                 goto illegal_op;
4507             }
4508 #endif
4509             rex_r = (~vex2 >> 4) & 8;
4510             if (b == 0xc5) {
4511                 vex3 = vex2;
4512                 b = cpu_ldub_code(env, s->pc++);
4513             } else {
4514 #ifdef TARGET_X86_64
4515                 s->rex_x = (~vex2 >> 3) & 8;
4516                 s->rex_b = (~vex2 >> 2) & 8;
4517 #endif
4518                 vex3 = cpu_ldub_code(env, s->pc++);
4519                 rex_w = (vex3 >> 7) & 1;
4520                 switch (vex2 & 0x1f) {
4521                 case 0x01: /* Implied 0f leading opcode bytes.  */
4522                     b = cpu_ldub_code(env, s->pc++) | 0x100;
4523                     break;
4524                 case 0x02: /* Implied 0f 38 leading opcode bytes.  */
4525                     b = 0x138;
4526                     break;
4527                 case 0x03: /* Implied 0f 3a leading opcode bytes.  */
4528                     b = 0x13a;
4529                     break;
4530                 default:   /* Reserved for future use.  */
4531                     goto illegal_op;
4532                 }
4533             }
4534             s->vex_v = (~vex3 >> 3) & 0xf;
4535             s->vex_l = (vex3 >> 2) & 1;
4536             prefixes |= pp_prefix[vex3 & 3] | PREFIX_VEX;
4537         }
4538         break;
4539     }
4540
4541     /* Post-process prefixes.  */
4542     if (CODE64(s)) {
4543         /* In 64-bit mode, the default data size is 32-bit.  Select 64-bit
4544            data with rex_w, and 16-bit data with 0x66; rex_w takes precedence
4545            over 0x66 if both are present.  */
4546         dflag = (rex_w > 0 ? MO_64 : prefixes & PREFIX_DATA ? MO_16 : MO_32);
4547         /* In 64-bit mode, 0x67 selects 32-bit addressing.  */
4548         aflag = (prefixes & PREFIX_ADR ? MO_32 : MO_64);
4549     } else {
4550         /* In 16/32-bit mode, 0x66 selects the opposite data size.  */
4551         if (s->code32 ^ ((prefixes & PREFIX_DATA) != 0)) {
4552             dflag = MO_32;
4553         } else {
4554             dflag = MO_16;
4555         }
4556         /* In 16/32-bit mode, 0x67 selects the opposite addressing.  */
4557         if (s->code32 ^ ((prefixes & PREFIX_ADR) != 0)) {
4558             aflag = MO_32;
4559         }  else {
4560             aflag = MO_16;
4561         }
4562     }
4563
4564     s->prefix = prefixes;
4565     s->aflag = aflag;
4566     s->dflag = dflag;
4567
4568     /* lock generation */
4569     if (prefixes & PREFIX_LOCK)
4570         gen_helper_lock();
4571
4572     /* now check op code */
4573  reswitch:
4574     switch(b) {
4575     case 0x0f:
4576         /**************************/
4577         /* extended op code */
4578         b = cpu_ldub_code(env, s->pc++) | 0x100;
4579         goto reswitch;
4580
4581         /**************************/
4582         /* arith & logic */
4583     case 0x00 ... 0x05:
4584     case 0x08 ... 0x0d:
4585     case 0x10 ... 0x15:
4586     case 0x18 ... 0x1d:
4587     case 0x20 ... 0x25:
4588     case 0x28 ... 0x2d:
4589     case 0x30 ... 0x35:
4590     case 0x38 ... 0x3d:
4591         {
4592             int op, f, val;
4593             op = (b >> 3) & 7;
4594             f = (b >> 1) & 3;
4595
4596             ot = mo_b_d(b, dflag);
4597
4598             switch(f) {
4599             case 0: /* OP Ev, Gv */
4600                 modrm = cpu_ldub_code(env, s->pc++);
4601                 reg = ((modrm >> 3) & 7) | rex_r;
4602                 mod = (modrm >> 6) & 3;
4603                 rm = (modrm & 7) | REX_B(s);
4604                 if (mod != 3) {
4605                     gen_lea_modrm(env, s, modrm);
4606                     opreg = OR_TMP0;
4607                 } else if (op == OP_XORL && rm == reg) {
4608                 xor_zero:
4609                     /* xor reg, reg optimisation */
4610                     set_cc_op(s, CC_OP_CLR);
4611                     tcg_gen_movi_tl(cpu_T[0], 0);
4612                     gen_op_mov_reg_v(ot, reg, cpu_T[0]);
4613                     break;
4614                 } else {
4615                     opreg = rm;
4616                 }
4617                 gen_op_mov_v_reg(ot, cpu_T[1], reg);
4618                 gen_op(s, op, ot, opreg);
4619                 break;
4620             case 1: /* OP Gv, Ev */
4621                 modrm = cpu_ldub_code(env, s->pc++);
4622                 mod = (modrm >> 6) & 3;
4623                 reg = ((modrm >> 3) & 7) | rex_r;
4624                 rm = (modrm & 7) | REX_B(s);
4625                 if (mod != 3) {
4626                     gen_lea_modrm(env, s, modrm);
4627                     gen_op_ld_v(s, ot, cpu_T[1], cpu_A0);
4628                 } else if (op == OP_XORL && rm == reg) {
4629                     goto xor_zero;
4630                 } else {
4631                     gen_op_mov_v_reg(ot, cpu_T[1], rm);
4632                 }
4633                 gen_op(s, op, ot, reg);
4634                 break;
4635             case 2: /* OP A, Iv */
4636                 val = insn_get(env, s, ot);
4637                 tcg_gen_movi_tl(cpu_T[1], val);
4638                 gen_op(s, op, ot, OR_EAX);
4639                 break;
4640             }
4641         }
4642         break;
4643
4644     case 0x82:
4645         if (CODE64(s))
4646             goto illegal_op;
4647     case 0x80: /* GRP1 */
4648     case 0x81:
4649     case 0x83:
4650         {
4651             int val;
4652
4653             ot = mo_b_d(b, dflag);
4654
4655             modrm = cpu_ldub_code(env, s->pc++);
4656             mod = (modrm >> 6) & 3;
4657             rm = (modrm & 7) | REX_B(s);
4658             op = (modrm >> 3) & 7;
4659
4660             if (mod != 3) {
4661                 if (b == 0x83)
4662                     s->rip_offset = 1;
4663                 else
4664                     s->rip_offset = insn_const_size(ot);
4665                 gen_lea_modrm(env, s, modrm);
4666                 opreg = OR_TMP0;
4667             } else {
4668                 opreg = rm;
4669             }
4670
4671             switch(b) {
4672             default:
4673             case 0x80:
4674             case 0x81:
4675             case 0x82:
4676                 val = insn_get(env, s, ot);
4677                 break;
4678             case 0x83:
4679                 val = (int8_t)insn_get(env, s, MO_8);
4680                 break;
4681             }
4682             tcg_gen_movi_tl(cpu_T[1], val);
4683             gen_op(s, op, ot, opreg);
4684         }
4685         break;
4686
4687         /**************************/
4688         /* inc, dec, and other misc arith */
4689     case 0x40 ... 0x47: /* inc Gv */
4690         ot = dflag;
4691         gen_inc(s, ot, OR_EAX + (b & 7), 1);
4692         break;
4693     case 0x48 ... 0x4f: /* dec Gv */
4694         ot = dflag;
4695         gen_inc(s, ot, OR_EAX + (b & 7), -1);
4696         break;
4697     case 0xf6: /* GRP3 */
4698     case 0xf7:
4699         ot = mo_b_d(b, dflag);
4700
4701         modrm = cpu_ldub_code(env, s->pc++);
4702         mod = (modrm >> 6) & 3;
4703         rm = (modrm & 7) | REX_B(s);
4704         op = (modrm >> 3) & 7;
4705         if (mod != 3) {
4706             if (op == 0)
4707                 s->rip_offset = insn_const_size(ot);
4708             gen_lea_modrm(env, s, modrm);
4709             gen_op_ld_v(s, ot, cpu_T[0], cpu_A0);
4710         } else {
4711             gen_op_mov_v_reg(ot, cpu_T[0], rm);
4712         }
4713
4714         switch(op) {
4715         case 0: /* test */
4716             val = insn_get(env, s, ot);
4717             tcg_gen_movi_tl(cpu_T[1], val);
4718             gen_op_testl_T0_T1_cc();
4719             set_cc_op(s, CC_OP_LOGICB + ot);
4720             break;
4721         case 2: /* not */
4722             tcg_gen_not_tl(cpu_T[0], cpu_T[0]);
4723             if (mod != 3) {
4724                 gen_op_st_v(s, ot, cpu_T[0], cpu_A0);
4725             } else {
4726                 gen_op_mov_reg_v(ot, rm, cpu_T[0]);
4727             }
4728             break;
4729         case 3: /* neg */
4730             tcg_gen_neg_tl(cpu_T[0], cpu_T[0]);
4731             if (mod != 3) {
4732                 gen_op_st_v(s, ot, cpu_T[0], cpu_A0);
4733             } else {
4734                 gen_op_mov_reg_v(ot, rm, cpu_T[0]);
4735             }
4736             gen_op_update_neg_cc();
4737             set_cc_op(s, CC_OP_SUBB + ot);
4738             break;
4739         case 4: /* mul */
4740             switch(ot) {
4741             case MO_8:
4742                 gen_op_mov_v_reg(MO_8, cpu_T[1], R_EAX);
4743                 tcg_gen_ext8u_tl(cpu_T[0], cpu_T[0]);
4744                 tcg_gen_ext8u_tl(cpu_T[1], cpu_T[1]);
4745                 /* XXX: use 32 bit mul which could be faster */
4746                 tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
4747                 gen_op_mov_reg_v(MO_16, R_EAX, cpu_T[0]);
4748                 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4749                 tcg_gen_andi_tl(cpu_cc_src, cpu_T[0], 0xff00);
4750                 set_cc_op(s, CC_OP_MULB);
4751                 break;
4752             case MO_16:
4753                 gen_op_mov_v_reg(MO_16, cpu_T[1], R_EAX);
4754                 tcg_gen_ext16u_tl(cpu_T[0], cpu_T[0]);
4755                 tcg_gen_ext16u_tl(cpu_T[1], cpu_T[1]);
4756                 /* XXX: use 32 bit mul which could be faster */
4757                 tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
4758                 gen_op_mov_reg_v(MO_16, R_EAX, cpu_T[0]);
4759                 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4760                 tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 16);
4761                 gen_op_mov_reg_v(MO_16, R_EDX, cpu_T[0]);
4762                 tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
4763                 set_cc_op(s, CC_OP_MULW);
4764                 break;
4765             default:
4766             case MO_32:
4767                 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
4768                 tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_regs[R_EAX]);
4769                 tcg_gen_mulu2_i32(cpu_tmp2_i32, cpu_tmp3_i32,
4770                                   cpu_tmp2_i32, cpu_tmp3_i32);
4771                 tcg_gen_extu_i32_tl(cpu_regs[R_EAX], cpu_tmp2_i32);
4772                 tcg_gen_extu_i32_tl(cpu_regs[R_EDX], cpu_tmp3_i32);
4773                 tcg_gen_mov_tl(cpu_cc_dst, cpu_regs[R_EAX]);
4774                 tcg_gen_mov_tl(cpu_cc_src, cpu_regs[R_EDX]);
4775                 set_cc_op(s, CC_OP_MULL);
4776                 break;
4777 #ifdef TARGET_X86_64
4778             case MO_64:
4779                 tcg_gen_mulu2_i64(cpu_regs[R_EAX], cpu_regs[R_EDX],
4780                                   cpu_T[0], cpu_regs[R_EAX]);
4781                 tcg_gen_mov_tl(cpu_cc_dst, cpu_regs[R_EAX]);
4782                 tcg_gen_mov_tl(cpu_cc_src, cpu_regs[R_EDX]);
4783                 set_cc_op(s, CC_OP_MULQ);
4784                 break;
4785 #endif
4786             }
4787             break;
4788         case 5: /* imul */
4789             switch(ot) {
4790             case MO_8:
4791                 gen_op_mov_v_reg(MO_8, cpu_T[1], R_EAX);
4792                 tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);
4793                 tcg_gen_ext8s_tl(cpu_T[1], cpu_T[1]);
4794                 /* XXX: use 32 bit mul which could be faster */
4795                 tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
4796                 gen_op_mov_reg_v(MO_16, R_EAX, cpu_T[0]);
4797                 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4798                 tcg_gen_ext8s_tl(cpu_tmp0, cpu_T[0]);
4799                 tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
4800                 set_cc_op(s, CC_OP_MULB);
4801                 break;
4802             case MO_16:
4803                 gen_op_mov_v_reg(MO_16, cpu_T[1], R_EAX);
4804                 tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
4805                 tcg_gen_ext16s_tl(cpu_T[1], cpu_T[1]);
4806                 /* XXX: use 32 bit mul which could be faster */
4807                 tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
4808                 gen_op_mov_reg_v(MO_16, R_EAX, cpu_T[0]);
4809                 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4810                 tcg_gen_ext16s_tl(cpu_tmp0, cpu_T[0]);
4811                 tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
4812                 tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 16);
4813                 gen_op_mov_reg_v(MO_16, R_EDX, cpu_T[0]);
4814                 set_cc_op(s, CC_OP_MULW);
4815                 break;
4816             default:
4817             case MO_32:
4818                 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
4819                 tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_regs[R_EAX]);
4820                 tcg_gen_muls2_i32(cpu_tmp2_i32, cpu_tmp3_i32,
4821                                   cpu_tmp2_i32, cpu_tmp3_i32);
4822                 tcg_gen_extu_i32_tl(cpu_regs[R_EAX], cpu_tmp2_i32);
4823                 tcg_gen_extu_i32_tl(cpu_regs[R_EDX], cpu_tmp3_i32);
4824                 tcg_gen_sari_i32(cpu_tmp2_i32, cpu_tmp2_i32, 31);
4825                 tcg_gen_mov_tl(cpu_cc_dst, cpu_regs[R_EAX]);
4826                 tcg_gen_sub_i32(cpu_tmp2_i32, cpu_tmp2_i32, cpu_tmp3_i32);
4827                 tcg_gen_extu_i32_tl(cpu_cc_src, cpu_tmp2_i32);
4828                 set_cc_op(s, CC_OP_MULL);
4829                 break;
4830 #ifdef TARGET_X86_64
4831             case MO_64:
4832                 tcg_gen_muls2_i64(cpu_regs[R_EAX], cpu_regs[R_EDX],
4833                                   cpu_T[0], cpu_regs[R_EAX]);
4834                 tcg_gen_mov_tl(cpu_cc_dst, cpu_regs[R_EAX]);
4835                 tcg_gen_sari_tl(cpu_cc_src, cpu_regs[R_EAX], 63);
4836                 tcg_gen_sub_tl(cpu_cc_src, cpu_cc_src, cpu_regs[R_EDX]);
4837                 set_cc_op(s, CC_OP_MULQ);
4838                 break;
4839 #endif
4840             }
4841             break;
4842         case 6: /* div */
4843             switch(ot) {
4844             case MO_8:
4845                 gen_jmp_im(pc_start - s->cs_base);
4846                 gen_helper_divb_AL(cpu_env, cpu_T[0]);
4847                 break;
4848             case MO_16:
4849                 gen_jmp_im(pc_start - s->cs_base);
4850                 gen_helper_divw_AX(cpu_env, cpu_T[0]);
4851                 break;
4852             default:
4853             case MO_32:
4854                 gen_jmp_im(pc_start - s->cs_base);
4855                 gen_helper_divl_EAX(cpu_env, cpu_T[0]);
4856                 break;
4857 #ifdef TARGET_X86_64
4858             case MO_64:
4859                 gen_jmp_im(pc_start - s->cs_base);
4860                 gen_helper_divq_EAX(cpu_env, cpu_T[0]);
4861                 break;
4862 #endif
4863             }
4864             break;
4865         case 7: /* idiv */
4866             switch(ot) {
4867             case MO_8:
4868                 gen_jmp_im(pc_start - s->cs_base);
4869                 gen_helper_idivb_AL(cpu_env, cpu_T[0]);
4870                 break;
4871             case MO_16:
4872                 gen_jmp_im(pc_start - s->cs_base);
4873                 gen_helper_idivw_AX(cpu_env, cpu_T[0]);
4874                 break;
4875             default:
4876             case MO_32:
4877                 gen_jmp_im(pc_start - s->cs_base);
4878                 gen_helper_idivl_EAX(cpu_env, cpu_T[0]);
4879                 break;
4880 #ifdef TARGET_X86_64
4881             case MO_64:
4882                 gen_jmp_im(pc_start - s->cs_base);
4883                 gen_helper_idivq_EAX(cpu_env, cpu_T[0]);
4884                 break;
4885 #endif
4886             }
4887             break;
4888         default:
4889             goto illegal_op;
4890         }
4891         break;
4892
4893     case 0xfe: /* GRP4 */
4894     case 0xff: /* GRP5 */
4895         ot = mo_b_d(b, dflag);
4896
4897         modrm = cpu_ldub_code(env, s->pc++);
4898         mod = (modrm >> 6) & 3;
4899         rm = (modrm & 7) | REX_B(s);
4900         op = (modrm >> 3) & 7;
4901         if (op >= 2 && b == 0xfe) {
4902             goto illegal_op;
4903         }
4904         if (CODE64(s)) {
4905             if (op == 2 || op == 4) {
4906                 /* operand size for jumps is 64 bit */
4907                 ot = MO_64;
4908             } else if (op == 3 || op == 5) {
4909                 ot = dflag != MO_16 ? MO_32 + (rex_w == 1) : MO_16;
4910             } else if (op == 6) {
4911                 /* default push size is 64 bit */
4912                 ot = mo_pushpop(s, dflag);
4913             }
4914         }
4915         if (mod != 3) {
4916             gen_lea_modrm(env, s, modrm);
4917             if (op >= 2 && op != 3 && op != 5)
4918                 gen_op_ld_v(s, ot, cpu_T[0], cpu_A0);
4919         } else {
4920             gen_op_mov_v_reg(ot, cpu_T[0], rm);
4921         }
4922
4923         switch(op) {
4924         case 0: /* inc Ev */
4925             if (mod != 3)
4926                 opreg = OR_TMP0;
4927             else
4928                 opreg = rm;
4929             gen_inc(s, ot, opreg, 1);
4930             break;
4931         case 1: /* dec Ev */
4932             if (mod != 3)
4933                 opreg = OR_TMP0;
4934             else
4935                 opreg = rm;
4936             gen_inc(s, ot, opreg, -1);
4937             break;
4938         case 2: /* call Ev */
4939             /* XXX: optimize if memory (no 'and' is necessary) */
4940             if (dflag == MO_16) {
4941                 tcg_gen_ext16u_tl(cpu_T[0], cpu_T[0]);
4942             }
4943             next_eip = s->pc - s->cs_base;
4944             tcg_gen_movi_tl(cpu_T[1], next_eip);
4945             gen_push_v(s, cpu_T[1]);
4946             gen_op_jmp_v(cpu_T[0]);
4947             gen_eob(s);
4948             break;
4949         case 3: /* lcall Ev */
4950             gen_op_ld_v(s, ot, cpu_T[1], cpu_A0);
4951             gen_add_A0_im(s, 1 << ot);
4952             gen_op_ld_v(s, MO_16, cpu_T[0], cpu_A0);
4953         do_lcall:
4954             if (s->pe && !s->vm86) {
4955                 gen_update_cc_op(s);
4956                 gen_jmp_im(pc_start - s->cs_base);
4957                 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
4958                 gen_helper_lcall_protected(cpu_env, cpu_tmp2_i32, cpu_T[1],
4959                                            tcg_const_i32(dflag - 1),
4960                                            tcg_const_i32(s->pc - pc_start));
4961             } else {
4962                 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
4963                 gen_helper_lcall_real(cpu_env, cpu_tmp2_i32, cpu_T[1],
4964                                       tcg_const_i32(dflag - 1),
4965                                       tcg_const_i32(s->pc - s->cs_base));
4966             }
4967             gen_eob(s);
4968             break;
4969         case 4: /* jmp Ev */
4970             if (dflag == MO_16) {
4971                 tcg_gen_ext16u_tl(cpu_T[0], cpu_T[0]);
4972             }
4973             gen_op_jmp_v(cpu_T[0]);
4974             gen_eob(s);
4975             break;
4976         case 5: /* ljmp Ev */
4977             gen_op_ld_v(s, ot, cpu_T[1], cpu_A0);
4978             gen_add_A0_im(s, 1 << ot);
4979             gen_op_ld_v(s, MO_16, cpu_T[0], cpu_A0);
4980         do_ljmp:
4981             if (s->pe && !s->vm86) {
4982                 gen_update_cc_op(s);
4983                 gen_jmp_im(pc_start - s->cs_base);
4984                 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
4985                 gen_helper_ljmp_protected(cpu_env, cpu_tmp2_i32, cpu_T[1],
4986                                           tcg_const_i32(s->pc - pc_start));
4987             } else {
4988                 gen_op_movl_seg_T0_vm(R_CS);
4989                 gen_op_jmp_v(cpu_T[1]);
4990             }
4991             gen_eob(s);
4992             break;
4993         case 6: /* push Ev */
4994             gen_push_v(s, cpu_T[0]);
4995             break;
4996         default:
4997             goto illegal_op;
4998         }
4999         break;
5000
5001     case 0x84: /* test Ev, Gv */
5002     case 0x85:
5003         ot = mo_b_d(b, dflag);
5004
5005         modrm = cpu_ldub_code(env, s->pc++);
5006         reg = ((modrm >> 3) & 7) | rex_r;
5007
5008         gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
5009         gen_op_mov_v_reg(ot, cpu_T[1], reg);
5010         gen_op_testl_T0_T1_cc();
5011         set_cc_op(s, CC_OP_LOGICB + ot);
5012         break;
5013
5014     case 0xa8: /* test eAX, Iv */
5015     case 0xa9:
5016         ot = mo_b_d(b, dflag);
5017         val = insn_get(env, s, ot);
5018
5019         gen_op_mov_v_reg(ot, cpu_T[0], OR_EAX);
5020         tcg_gen_movi_tl(cpu_T[1], val);
5021         gen_op_testl_T0_T1_cc();
5022         set_cc_op(s, CC_OP_LOGICB + ot);
5023         break;
5024
5025     case 0x98: /* CWDE/CBW */
5026         switch (dflag) {
5027 #ifdef TARGET_X86_64
5028         case MO_64:
5029             gen_op_mov_v_reg(MO_32, cpu_T[0], R_EAX);
5030             tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
5031             gen_op_mov_reg_v(MO_64, R_EAX, cpu_T[0]);
5032             break;
5033 #endif
5034         case MO_32:
5035             gen_op_mov_v_reg(MO_16, cpu_T[0], R_EAX);
5036             tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
5037             gen_op_mov_reg_v(MO_32, R_EAX, cpu_T[0]);
5038             break;
5039         case MO_16:
5040             gen_op_mov_v_reg(MO_8, cpu_T[0], R_EAX);
5041             tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);
5042             gen_op_mov_reg_v(MO_16, R_EAX, cpu_T[0]);
5043             break;
5044         default:
5045             tcg_abort();
5046         }
5047         break;
5048     case 0x99: /* CDQ/CWD */
5049         switch (dflag) {
5050 #ifdef TARGET_X86_64
5051         case MO_64:
5052             gen_op_mov_v_reg(MO_64, cpu_T[0], R_EAX);
5053             tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 63);
5054             gen_op_mov_reg_v(MO_64, R_EDX, cpu_T[0]);
5055             break;
5056 #endif
5057         case MO_32:
5058             gen_op_mov_v_reg(MO_32, cpu_T[0], R_EAX);
5059             tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
5060             tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 31);
5061             gen_op_mov_reg_v(MO_32, R_EDX, cpu_T[0]);
5062             break;
5063         case MO_16:
5064             gen_op_mov_v_reg(MO_16, cpu_T[0], R_EAX);
5065             tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
5066             tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 15);
5067             gen_op_mov_reg_v(MO_16, R_EDX, cpu_T[0]);
5068             break;
5069         default:
5070             tcg_abort();
5071         }
5072         break;
5073     case 0x1af: /* imul Gv, Ev */
5074     case 0x69: /* imul Gv, Ev, I */
5075     case 0x6b:
5076         ot = dflag;
5077         modrm = cpu_ldub_code(env, s->pc++);
5078         reg = ((modrm >> 3) & 7) | rex_r;
5079         if (b == 0x69)
5080             s->rip_offset = insn_const_size(ot);
5081         else if (b == 0x6b)
5082             s->rip_offset = 1;
5083         gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
5084         if (b == 0x69) {
5085             val = insn_get(env, s, ot);
5086             tcg_gen_movi_tl(cpu_T[1], val);
5087         } else if (b == 0x6b) {
5088             val = (int8_t)insn_get(env, s, MO_8);
5089             tcg_gen_movi_tl(cpu_T[1], val);
5090         } else {
5091             gen_op_mov_v_reg(ot, cpu_T[1], reg);
5092         }
5093         switch (ot) {
5094 #ifdef TARGET_X86_64
5095         case MO_64:
5096             tcg_gen_muls2_i64(cpu_regs[reg], cpu_T[1], cpu_T[0], cpu_T[1]);
5097             tcg_gen_mov_tl(cpu_cc_dst, cpu_regs[reg]);
5098             tcg_gen_sari_tl(cpu_cc_src, cpu_cc_dst, 63);
5099             tcg_gen_sub_tl(cpu_cc_src, cpu_cc_src, cpu_T[1]);
5100             break;
5101 #endif
5102         case MO_32:
5103             tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
5104             tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[1]);
5105             tcg_gen_muls2_i32(cpu_tmp2_i32, cpu_tmp3_i32,
5106                               cpu_tmp2_i32, cpu_tmp3_i32);
5107             tcg_gen_extu_i32_tl(cpu_regs[reg], cpu_tmp2_i32);
5108             tcg_gen_sari_i32(cpu_tmp2_i32, cpu_tmp2_i32, 31);
5109             tcg_gen_mov_tl(cpu_cc_dst, cpu_regs[reg]);
5110             tcg_gen_sub_i32(cpu_tmp2_i32, cpu_tmp2_i32, cpu_tmp3_i32);
5111             tcg_gen_extu_i32_tl(cpu_cc_src, cpu_tmp2_i32);
5112             break;
5113         default:
5114             tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
5115             tcg_gen_ext16s_tl(cpu_T[1], cpu_T[1]);
5116             /* XXX: use 32 bit mul which could be faster */
5117             tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
5118             tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
5119             tcg_gen_ext16s_tl(cpu_tmp0, cpu_T[0]);
5120             tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
5121             gen_op_mov_reg_v(ot, reg, cpu_T[0]);
5122             break;
5123         }
5124         set_cc_op(s, CC_OP_MULB + ot);
5125         break;
5126     case 0x1c0:
5127     case 0x1c1: /* xadd Ev, Gv */
5128         ot = mo_b_d(b, dflag);
5129         modrm = cpu_ldub_code(env, s->pc++);
5130         reg = ((modrm >> 3) & 7) | rex_r;
5131         mod = (modrm >> 6) & 3;
5132         if (mod == 3) {
5133             rm = (modrm & 7) | REX_B(s);
5134             gen_op_mov_v_reg(ot, cpu_T[0], reg);
5135             gen_op_mov_v_reg(ot, cpu_T[1], rm);
5136             tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
5137             gen_op_mov_reg_v(ot, reg, cpu_T[1]);
5138             gen_op_mov_reg_v(ot, rm, cpu_T[0]);
5139         } else {
5140             gen_lea_modrm(env, s, modrm);
5141             gen_op_mov_v_reg(ot, cpu_T[0], reg);
5142             gen_op_ld_v(s, ot, cpu_T[1], cpu_A0);
5143             tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
5144             gen_op_st_v(s, ot, cpu_T[0], cpu_A0);
5145             gen_op_mov_reg_v(ot, reg, cpu_T[1]);
5146         }
5147         gen_op_update2_cc();
5148         set_cc_op(s, CC_OP_ADDB + ot);
5149         break;
5150     case 0x1b0:
5151     case 0x1b1: /* cmpxchg Ev, Gv */
5152         {
5153             int label1, label2;
5154             TCGv t0, t1, t2, a0;
5155
5156             ot = mo_b_d(b, dflag);
5157             modrm = cpu_ldub_code(env, s->pc++);
5158             reg = ((modrm >> 3) & 7) | rex_r;
5159             mod = (modrm >> 6) & 3;
5160             t0 = tcg_temp_local_new();
5161             t1 = tcg_temp_local_new();
5162             t2 = tcg_temp_local_new();
5163             a0 = tcg_temp_local_new();
5164             gen_op_mov_v_reg(ot, t1, reg);
5165             if (mod == 3) {
5166                 rm = (modrm & 7) | REX_B(s);
5167                 gen_op_mov_v_reg(ot, t0, rm);
5168             } else {
5169                 gen_lea_modrm(env, s, modrm);
5170                 tcg_gen_mov_tl(a0, cpu_A0);
5171                 gen_op_ld_v(s, ot, t0, a0);
5172                 rm = 0; /* avoid warning */
5173             }
5174             label1 = gen_new_label();
5175             tcg_gen_mov_tl(t2, cpu_regs[R_EAX]);
5176             gen_extu(ot, t0);
5177             gen_extu(ot, t2);
5178             tcg_gen_brcond_tl(TCG_COND_EQ, t2, t0, label1);
5179             label2 = gen_new_label();
5180             if (mod == 3) {
5181                 gen_op_mov_reg_v(ot, R_EAX, t0);
5182                 tcg_gen_br(label2);
5183                 gen_set_label(label1);
5184                 gen_op_mov_reg_v(ot, rm, t1);
5185             } else {
5186                 /* perform no-op store cycle like physical cpu; must be
5187                    before changing accumulator to ensure idempotency if
5188                    the store faults and the instruction is restarted */
5189                 gen_op_st_v(s, ot, t0, a0);
5190                 gen_op_mov_reg_v(ot, R_EAX, t0);
5191                 tcg_gen_br(label2);
5192                 gen_set_label(label1);
5193                 gen_op_st_v(s, ot, t1, a0);
5194             }
5195             gen_set_label(label2);
5196             tcg_gen_mov_tl(cpu_cc_src, t0);
5197             tcg_gen_mov_tl(cpu_cc_srcT, t2);
5198             tcg_gen_sub_tl(cpu_cc_dst, t2, t0);
5199             set_cc_op(s, CC_OP_SUBB + ot);
5200             tcg_temp_free(t0);
5201             tcg_temp_free(t1);
5202             tcg_temp_free(t2);
5203             tcg_temp_free(a0);
5204         }
5205         break;
5206     case 0x1c7: /* cmpxchg8b */
5207         modrm = cpu_ldub_code(env, s->pc++);
5208         mod = (modrm >> 6) & 3;
5209         if ((mod == 3) || ((modrm & 0x38) != 0x8))
5210             goto illegal_op;
5211 #ifdef TARGET_X86_64
5212         if (dflag == MO_64) {
5213             if (!(s->cpuid_ext_features & CPUID_EXT_CX16))
5214                 goto illegal_op;
5215             gen_jmp_im(pc_start - s->cs_base);
5216             gen_update_cc_op(s);
5217             gen_lea_modrm(env, s, modrm);
5218             gen_helper_cmpxchg16b(cpu_env, cpu_A0);
5219         } else
5220 #endif
5221         {
5222             if (!(s->cpuid_features & CPUID_CX8))
5223                 goto illegal_op;
5224             gen_jmp_im(pc_start - s->cs_base);
5225             gen_update_cc_op(s);
5226             gen_lea_modrm(env, s, modrm);
5227             gen_helper_cmpxchg8b(cpu_env, cpu_A0);
5228         }
5229         set_cc_op(s, CC_OP_EFLAGS);
5230         break;
5231
5232         /**************************/
5233         /* push/pop */
5234     case 0x50 ... 0x57: /* push */
5235         gen_op_mov_v_reg(MO_32, cpu_T[0], (b & 7) | REX_B(s));
5236         gen_push_v(s, cpu_T[0]);
5237         break;
5238     case 0x58 ... 0x5f: /* pop */
5239         ot = gen_pop_T0(s);
5240         /* NOTE: order is important for pop %sp */
5241         gen_pop_update(s, ot);
5242         gen_op_mov_reg_v(ot, (b & 7) | REX_B(s), cpu_T[0]);
5243         break;
5244     case 0x60: /* pusha */
5245         if (CODE64(s))
5246             goto illegal_op;
5247         gen_pusha(s);
5248         break;
5249     case 0x61: /* popa */
5250         if (CODE64(s))
5251             goto illegal_op;
5252         gen_popa(s);
5253         break;
5254     case 0x68: /* push Iv */
5255     case 0x6a:
5256         ot = mo_pushpop(s, dflag);
5257         if (b == 0x68)
5258             val = insn_get(env, s, ot);
5259         else
5260             val = (int8_t)insn_get(env, s, MO_8);
5261         tcg_gen_movi_tl(cpu_T[0], val);
5262         gen_push_v(s, cpu_T[0]);
5263         break;
5264     case 0x8f: /* pop Ev */
5265         modrm = cpu_ldub_code(env, s->pc++);
5266         mod = (modrm >> 6) & 3;
5267         ot = gen_pop_T0(s);
5268         if (mod == 3) {
5269             /* NOTE: order is important for pop %sp */
5270             gen_pop_update(s, ot);
5271             rm = (modrm & 7) | REX_B(s);
5272             gen_op_mov_reg_v(ot, rm, cpu_T[0]);
5273         } else {
5274             /* NOTE: order is important too for MMU exceptions */
5275             s->popl_esp_hack = 1 << ot;
5276             gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 1);
5277             s->popl_esp_hack = 0;
5278             gen_pop_update(s, ot);
5279         }
5280         break;
5281     case 0xc8: /* enter */
5282         {
5283             int level;
5284             val = cpu_lduw_code(env, s->pc);
5285             s->pc += 2;
5286             level = cpu_ldub_code(env, s->pc++);
5287             gen_enter(s, val, level);
5288         }
5289         break;
5290     case 0xc9: /* leave */
5291         /* XXX: exception not precise (ESP is updated before potential exception) */
5292         if (CODE64(s)) {
5293             gen_op_mov_v_reg(MO_64, cpu_T[0], R_EBP);
5294             gen_op_mov_reg_v(MO_64, R_ESP, cpu_T[0]);
5295         } else if (s->ss32) {
5296             gen_op_mov_v_reg(MO_32, cpu_T[0], R_EBP);
5297             gen_op_mov_reg_v(MO_32, R_ESP, cpu_T[0]);
5298         } else {
5299             gen_op_mov_v_reg(MO_16, cpu_T[0], R_EBP);
5300             gen_op_mov_reg_v(MO_16, R_ESP, cpu_T[0]);
5301         }
5302         ot = gen_pop_T0(s);
5303         gen_op_mov_reg_v(ot, R_EBP, cpu_T[0]);
5304         gen_pop_update(s, ot);
5305         break;
5306     case 0x06: /* push es */
5307     case 0x0e: /* push cs */
5308     case 0x16: /* push ss */
5309     case 0x1e: /* push ds */
5310         if (CODE64(s))
5311             goto illegal_op;
5312         gen_op_movl_T0_seg(b >> 3);
5313         gen_push_v(s, cpu_T[0]);
5314         break;
5315     case 0x1a0: /* push fs */
5316     case 0x1a8: /* push gs */
5317         gen_op_movl_T0_seg((b >> 3) & 7);
5318         gen_push_v(s, cpu_T[0]);
5319         break;
5320     case 0x07: /* pop es */
5321     case 0x17: /* pop ss */
5322     case 0x1f: /* pop ds */
5323         if (CODE64(s))
5324             goto illegal_op;
5325         reg = b >> 3;
5326         ot = gen_pop_T0(s);
5327         gen_movl_seg_T0(s, reg, pc_start - s->cs_base);
5328         gen_pop_update(s, ot);
5329         if (reg == R_SS) {
5330             /* if reg == SS, inhibit interrupts/trace. */
5331             /* If several instructions disable interrupts, only the
5332                _first_ does it */
5333             if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
5334                 gen_helper_set_inhibit_irq(cpu_env);
5335             s->tf = 0;
5336         }
5337         if (s->is_jmp) {
5338             gen_jmp_im(s->pc - s->cs_base);
5339             gen_eob(s);
5340         }
5341         break;
5342     case 0x1a1: /* pop fs */
5343     case 0x1a9: /* pop gs */
5344         ot = gen_pop_T0(s);
5345         gen_movl_seg_T0(s, (b >> 3) & 7, pc_start - s->cs_base);
5346         gen_pop_update(s, ot);
5347         if (s->is_jmp) {
5348             gen_jmp_im(s->pc - s->cs_base);
5349             gen_eob(s);
5350         }
5351         break;
5352
5353         /**************************/
5354         /* mov */
5355     case 0x88:
5356     case 0x89: /* mov Gv, Ev */
5357         ot = mo_b_d(b, dflag);
5358         modrm = cpu_ldub_code(env, s->pc++);
5359         reg = ((modrm >> 3) & 7) | rex_r;
5360
5361         /* generate a generic store */
5362         gen_ldst_modrm(env, s, modrm, ot, reg, 1);
5363         break;
5364     case 0xc6:
5365     case 0xc7: /* mov Ev, Iv */
5366         ot = mo_b_d(b, dflag);
5367         modrm = cpu_ldub_code(env, s->pc++);
5368         mod = (modrm >> 6) & 3;
5369         if (mod != 3) {
5370             s->rip_offset = insn_const_size(ot);
5371             gen_lea_modrm(env, s, modrm);
5372         }
5373         val = insn_get(env, s, ot);
5374         tcg_gen_movi_tl(cpu_T[0], val);
5375         if (mod != 3) {
5376             gen_op_st_v(s, ot, cpu_T[0], cpu_A0);
5377         } else {
5378             gen_op_mov_reg_v(ot, (modrm & 7) | REX_B(s), cpu_T[0]);
5379         }
5380         break;
5381     case 0x8a:
5382     case 0x8b: /* mov Ev, Gv */
5383         ot = mo_b_d(b, dflag);
5384         modrm = cpu_ldub_code(env, s->pc++);
5385         reg = ((modrm >> 3) & 7) | rex_r;
5386
5387         gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
5388         gen_op_mov_reg_v(ot, reg, cpu_T[0]);
5389         break;
5390     case 0x8e: /* mov seg, Gv */
5391         modrm = cpu_ldub_code(env, s->pc++);
5392         reg = (modrm >> 3) & 7;
5393         if (reg >= 6 || reg == R_CS)
5394             goto illegal_op;
5395         gen_ldst_modrm(env, s, modrm, MO_16, OR_TMP0, 0);
5396         gen_movl_seg_T0(s, reg, pc_start - s->cs_base);
5397         if (reg == R_SS) {
5398             /* if reg == SS, inhibit interrupts/trace */
5399             /* If several instructions disable interrupts, only the
5400                _first_ does it */
5401             if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
5402                 gen_helper_set_inhibit_irq(cpu_env);
5403             s->tf = 0;
5404         }
5405         if (s->is_jmp) {
5406             gen_jmp_im(s->pc - s->cs_base);
5407             gen_eob(s);
5408         }
5409         break;
5410     case 0x8c: /* mov Gv, seg */
5411         modrm = cpu_ldub_code(env, s->pc++);
5412         reg = (modrm >> 3) & 7;
5413         mod = (modrm >> 6) & 3;
5414         if (reg >= 6)
5415             goto illegal_op;
5416         gen_op_movl_T0_seg(reg);
5417         ot = mod == 3 ? dflag : MO_16;
5418         gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 1);
5419         break;
5420
5421     case 0x1b6: /* movzbS Gv, Eb */
5422     case 0x1b7: /* movzwS Gv, Eb */
5423     case 0x1be: /* movsbS Gv, Eb */
5424     case 0x1bf: /* movswS Gv, Eb */
5425         {
5426             TCGMemOp d_ot;
5427             TCGMemOp s_ot;
5428
5429             /* d_ot is the size of destination */
5430             d_ot = dflag;
5431             /* ot is the size of source */
5432             ot = (b & 1) + MO_8;
5433             /* s_ot is the sign+size of source */
5434             s_ot = b & 8 ? MO_SIGN | ot : ot;
5435
5436             modrm = cpu_ldub_code(env, s->pc++);
5437             reg = ((modrm >> 3) & 7) | rex_r;
5438             mod = (modrm >> 6) & 3;
5439             rm = (modrm & 7) | REX_B(s);
5440
5441             if (mod == 3) {
5442                 gen_op_mov_v_reg(ot, cpu_T[0], rm);
5443                 switch (s_ot) {
5444                 case MO_UB:
5445                     tcg_gen_ext8u_tl(cpu_T[0], cpu_T[0]);
5446                     break;
5447                 case MO_SB:
5448                     tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);
5449                     break;
5450                 case MO_UW:
5451                     tcg_gen_ext16u_tl(cpu_T[0], cpu_T[0]);
5452                     break;
5453                 default:
5454                 case MO_SW:
5455                     tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
5456                     break;
5457                 }
5458                 gen_op_mov_reg_v(d_ot, reg, cpu_T[0]);
5459             } else {
5460                 gen_lea_modrm(env, s, modrm);
5461                 gen_op_ld_v(s, s_ot, cpu_T[0], cpu_A0);
5462                 gen_op_mov_reg_v(d_ot, reg, cpu_T[0]);
5463             }
5464         }
5465         break;
5466
5467     case 0x8d: /* lea */
5468         ot = dflag;
5469         modrm = cpu_ldub_code(env, s->pc++);
5470         mod = (modrm >> 6) & 3;
5471         if (mod == 3)
5472             goto illegal_op;
5473         reg = ((modrm >> 3) & 7) | rex_r;
5474         /* we must ensure that no segment is added */
5475         s->override = -1;
5476         val = s->addseg;
5477         s->addseg = 0;
5478         gen_lea_modrm(env, s, modrm);
5479         s->addseg = val;
5480         gen_op_mov_reg_v(ot, reg, cpu_A0);
5481         break;
5482
5483     case 0xa0: /* mov EAX, Ov */
5484     case 0xa1:
5485     case 0xa2: /* mov Ov, EAX */
5486     case 0xa3:
5487         {
5488             target_ulong offset_addr;
5489
5490             ot = mo_b_d(b, dflag);
5491             switch (s->aflag) {
5492 #ifdef TARGET_X86_64
5493             case MO_64:
5494                 offset_addr = cpu_ldq_code(env, s->pc);
5495                 s->pc += 8;
5496                 break;
5497 #endif
5498             default:
5499                 offset_addr = insn_get(env, s, s->aflag);
5500                 break;
5501             }
5502             tcg_gen_movi_tl(cpu_A0, offset_addr);
5503             gen_add_A0_ds_seg(s);
5504             if ((b & 2) == 0) {
5505                 gen_op_ld_v(s, ot, cpu_T[0], cpu_A0);
5506                 gen_op_mov_reg_v(ot, R_EAX, cpu_T[0]);
5507             } else {
5508                 gen_op_mov_v_reg(ot, cpu_T[0], R_EAX);
5509                 gen_op_st_v(s, ot, cpu_T[0], cpu_A0);
5510             }
5511         }
5512         break;
5513     case 0xd7: /* xlat */
5514         tcg_gen_mov_tl(cpu_A0, cpu_regs[R_EBX]);
5515         tcg_gen_ext8u_tl(cpu_T[0], cpu_regs[R_EAX]);
5516         tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_T[0]);
5517         gen_extu(s->aflag, cpu_A0);
5518         gen_add_A0_ds_seg(s);
5519         gen_op_ld_v(s, MO_8, cpu_T[0], cpu_A0);
5520         gen_op_mov_reg_v(MO_8, R_EAX, cpu_T[0]);
5521         break;
5522     case 0xb0 ... 0xb7: /* mov R, Ib */
5523         val = insn_get(env, s, MO_8);
5524         tcg_gen_movi_tl(cpu_T[0], val);
5525         gen_op_mov_reg_v(MO_8, (b & 7) | REX_B(s), cpu_T[0]);
5526         break;
5527     case 0xb8 ... 0xbf: /* mov R, Iv */
5528 #ifdef TARGET_X86_64
5529         if (dflag == MO_64) {
5530             uint64_t tmp;
5531             /* 64 bit case */
5532             tmp = cpu_ldq_code(env, s->pc);
5533             s->pc += 8;
5534             reg = (b & 7) | REX_B(s);
5535             tcg_gen_movi_tl(cpu_T[0], tmp);
5536             gen_op_mov_reg_v(MO_64, reg, cpu_T[0]);
5537         } else
5538 #endif
5539         {
5540             ot = dflag;
5541             val = insn_get(env, s, ot);
5542             reg = (b & 7) | REX_B(s);
5543             tcg_gen_movi_tl(cpu_T[0], val);
5544             gen_op_mov_reg_v(ot, reg, cpu_T[0]);
5545         }
5546         break;
5547
5548     case 0x91 ... 0x97: /* xchg R, EAX */
5549     do_xchg_reg_eax:
5550         ot = dflag;
5551         reg = (b & 7) | REX_B(s);
5552         rm = R_EAX;
5553         goto do_xchg_reg;
5554     case 0x86:
5555     case 0x87: /* xchg Ev, Gv */
5556         ot = mo_b_d(b, dflag);
5557         modrm = cpu_ldub_code(env, s->pc++);
5558         reg = ((modrm >> 3) & 7) | rex_r;
5559         mod = (modrm >> 6) & 3;
5560         if (mod == 3) {
5561             rm = (modrm & 7) | REX_B(s);
5562         do_xchg_reg:
5563             gen_op_mov_v_reg(ot, cpu_T[0], reg);
5564             gen_op_mov_v_reg(ot, cpu_T[1], rm);
5565             gen_op_mov_reg_v(ot, rm, cpu_T[0]);
5566             gen_op_mov_reg_v(ot, reg, cpu_T[1]);
5567         } else {
5568             gen_lea_modrm(env, s, modrm);
5569             gen_op_mov_v_reg(ot, cpu_T[0], reg);
5570             /* for xchg, lock is implicit */
5571             if (!(prefixes & PREFIX_LOCK))
5572                 gen_helper_lock();
5573             gen_op_ld_v(s, ot, cpu_T[1], cpu_A0);
5574             gen_op_st_v(s, ot, cpu_T[0], cpu_A0);
5575             if (!(prefixes & PREFIX_LOCK))
5576                 gen_helper_unlock();
5577             gen_op_mov_reg_v(ot, reg, cpu_T[1]);
5578         }
5579         break;
5580     case 0xc4: /* les Gv */
5581         /* In CODE64 this is VEX3; see above.  */
5582         op = R_ES;
5583         goto do_lxx;
5584     case 0xc5: /* lds Gv */
5585         /* In CODE64 this is VEX2; see above.  */
5586         op = R_DS;
5587         goto do_lxx;
5588     case 0x1b2: /* lss Gv */
5589         op = R_SS;
5590         goto do_lxx;
5591     case 0x1b4: /* lfs Gv */
5592         op = R_FS;
5593         goto do_lxx;
5594     case 0x1b5: /* lgs Gv */
5595         op = R_GS;
5596     do_lxx:
5597         ot = dflag != MO_16 ? MO_32 : MO_16;
5598         modrm = cpu_ldub_code(env, s->pc++);
5599         reg = ((modrm >> 3) & 7) | rex_r;
5600         mod = (modrm >> 6) & 3;
5601         if (mod == 3)
5602             goto illegal_op;
5603         gen_lea_modrm(env, s, modrm);
5604         gen_op_ld_v(s, ot, cpu_T[1], cpu_A0);
5605         gen_add_A0_im(s, 1 << ot);
5606         /* load the segment first to handle exceptions properly */
5607         gen_op_ld_v(s, MO_16, cpu_T[0], cpu_A0);
5608         gen_movl_seg_T0(s, op, pc_start - s->cs_base);
5609         /* then put the data */
5610         gen_op_mov_reg_v(ot, reg, cpu_T[1]);
5611         if (s->is_jmp) {
5612             gen_jmp_im(s->pc - s->cs_base);
5613             gen_eob(s);
5614         }
5615         break;
5616
5617         /************************/
5618         /* shifts */
5619     case 0xc0:
5620     case 0xc1:
5621         /* shift Ev,Ib */
5622         shift = 2;
5623     grp2:
5624         {
5625             ot = mo_b_d(b, dflag);
5626             modrm = cpu_ldub_code(env, s->pc++);
5627             mod = (modrm >> 6) & 3;
5628             op = (modrm >> 3) & 7;
5629
5630             if (mod != 3) {
5631                 if (shift == 2) {
5632                     s->rip_offset = 1;
5633                 }
5634                 gen_lea_modrm(env, s, modrm);
5635                 opreg = OR_TMP0;
5636             } else {
5637                 opreg = (modrm & 7) | REX_B(s);
5638             }
5639
5640             /* simpler op */
5641             if (shift == 0) {
5642                 gen_shift(s, op, ot, opreg, OR_ECX);
5643             } else {
5644                 if (shift == 2) {
5645                     shift = cpu_ldub_code(env, s->pc++);
5646                 }
5647                 gen_shifti(s, op, ot, opreg, shift);
5648             }
5649         }
5650         break;
5651     case 0xd0:
5652     case 0xd1:
5653         /* shift Ev,1 */
5654         shift = 1;
5655         goto grp2;
5656     case 0xd2:
5657     case 0xd3:
5658         /* shift Ev,cl */
5659         shift = 0;
5660         goto grp2;
5661
5662     case 0x1a4: /* shld imm */
5663         op = 0;
5664         shift = 1;
5665         goto do_shiftd;
5666     case 0x1a5: /* shld cl */
5667         op = 0;
5668         shift = 0;
5669         goto do_shiftd;
5670     case 0x1ac: /* shrd imm */
5671         op = 1;
5672         shift = 1;
5673         goto do_shiftd;
5674     case 0x1ad: /* shrd cl */
5675         op = 1;
5676         shift = 0;
5677     do_shiftd:
5678         ot = dflag;
5679         modrm = cpu_ldub_code(env, s->pc++);
5680         mod = (modrm >> 6) & 3;
5681         rm = (modrm & 7) | REX_B(s);
5682         reg = ((modrm >> 3) & 7) | rex_r;
5683         if (mod != 3) {
5684             gen_lea_modrm(env, s, modrm);
5685             opreg = OR_TMP0;
5686         } else {
5687             opreg = rm;
5688         }
5689         gen_op_mov_v_reg(ot, cpu_T[1], reg);
5690
5691         if (shift) {
5692             TCGv imm = tcg_const_tl(cpu_ldub_code(env, s->pc++));
5693             gen_shiftd_rm_T1(s, ot, opreg, op, imm);
5694             tcg_temp_free(imm);
5695         } else {
5696             gen_shiftd_rm_T1(s, ot, opreg, op, cpu_regs[R_ECX]);
5697         }
5698         break;
5699
5700         /************************/
5701         /* floats */
5702     case 0xd8 ... 0xdf:
5703         if (s->flags & (HF_EM_MASK | HF_TS_MASK)) {
5704             /* if CR0.EM or CR0.TS are set, generate an FPU exception */
5705             /* XXX: what to do if illegal op ? */
5706             gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
5707             break;
5708         }
5709         modrm = cpu_ldub_code(env, s->pc++);
5710         mod = (modrm >> 6) & 3;
5711         rm = modrm & 7;
5712         op = ((b & 7) << 3) | ((modrm >> 3) & 7);
5713         if (mod != 3) {
5714             /* memory op */
5715             gen_lea_modrm(env, s, modrm);
5716             switch(op) {
5717             case 0x00 ... 0x07: /* fxxxs */
5718             case 0x10 ... 0x17: /* fixxxl */
5719             case 0x20 ... 0x27: /* fxxxl */
5720             case 0x30 ... 0x37: /* fixxx */
5721                 {
5722                     int op1;
5723                     op1 = op & 7;
5724
5725                     switch(op >> 4) {
5726                     case 0:
5727                         tcg_gen_qemu_ld_i32(cpu_tmp2_i32, cpu_A0,
5728                                             s->mem_index, MO_LEUL);
5729                         gen_helper_flds_FT0(cpu_env, cpu_tmp2_i32);
5730                         break;
5731                     case 1:
5732                         tcg_gen_qemu_ld_i32(cpu_tmp2_i32, cpu_A0,
5733                                             s->mem_index, MO_LEUL);
5734                         gen_helper_fildl_FT0(cpu_env, cpu_tmp2_i32);
5735                         break;
5736                     case 2:
5737                         tcg_gen_qemu_ld_i64(cpu_tmp1_i64, cpu_A0,
5738                                             s->mem_index, MO_LEQ);
5739                         gen_helper_fldl_FT0(cpu_env, cpu_tmp1_i64);
5740                         break;
5741                     case 3:
5742                     default:
5743                         tcg_gen_qemu_ld_i32(cpu_tmp2_i32, cpu_A0,
5744                                             s->mem_index, MO_LESW);
5745                         gen_helper_fildl_FT0(cpu_env, cpu_tmp2_i32);
5746                         break;
5747                     }
5748
5749                     gen_helper_fp_arith_ST0_FT0(op1);
5750                     if (op1 == 3) {
5751                         /* fcomp needs pop */
5752                         gen_helper_fpop(cpu_env);
5753                     }
5754                 }
5755                 break;
5756             case 0x08: /* flds */
5757             case 0x0a: /* fsts */
5758             case 0x0b: /* fstps */
5759             case 0x18 ... 0x1b: /* fildl, fisttpl, fistl, fistpl */
5760             case 0x28 ... 0x2b: /* fldl, fisttpll, fstl, fstpl */
5761             case 0x38 ... 0x3b: /* filds, fisttps, fists, fistps */
5762                 switch(op & 7) {
5763                 case 0:
5764                     switch(op >> 4) {
5765                     case 0:
5766                         tcg_gen_qemu_ld_i32(cpu_tmp2_i32, cpu_A0,
5767                                             s->mem_index, MO_LEUL);
5768                         gen_helper_flds_ST0(cpu_env, cpu_tmp2_i32);
5769                         break;
5770                     case 1:
5771                         tcg_gen_qemu_ld_i32(cpu_tmp2_i32, cpu_A0,
5772                                             s->mem_index, MO_LEUL);
5773                         gen_helper_fildl_ST0(cpu_env, cpu_tmp2_i32);
5774                         break;
5775                     case 2:
5776                         tcg_gen_qemu_ld_i64(cpu_tmp1_i64, cpu_A0,
5777                                             s->mem_index, MO_LEQ);
5778                         gen_helper_fldl_ST0(cpu_env, cpu_tmp1_i64);
5779                         break;
5780                     case 3:
5781                     default:
5782                         tcg_gen_qemu_ld_i32(cpu_tmp2_i32, cpu_A0,
5783                                             s->mem_index, MO_LESW);
5784                         gen_helper_fildl_ST0(cpu_env, cpu_tmp2_i32);
5785                         break;
5786                     }
5787                     break;
5788                 case 1:
5789                     /* XXX: the corresponding CPUID bit must be tested ! */
5790                     switch(op >> 4) {
5791                     case 1:
5792                         gen_helper_fisttl_ST0(cpu_tmp2_i32, cpu_env);
5793                         tcg_gen_qemu_st_i32(cpu_tmp2_i32, cpu_A0,
5794                                             s->mem_index, MO_LEUL);
5795                         break;
5796                     case 2:
5797                         gen_helper_fisttll_ST0(cpu_tmp1_i64, cpu_env);
5798                         tcg_gen_qemu_st_i64(cpu_tmp1_i64, cpu_A0,
5799                                             s->mem_index, MO_LEQ);
5800                         break;
5801                     case 3:
5802                     default:
5803                         gen_helper_fistt_ST0(cpu_tmp2_i32, cpu_env);
5804                         tcg_gen_qemu_st_i32(cpu_tmp2_i32, cpu_A0,
5805                                             s->mem_index, MO_LEUW);
5806                         break;
5807                     }
5808                     gen_helper_fpop(cpu_env);
5809                     break;
5810                 default:
5811                     switch(op >> 4) {
5812                     case 0:
5813                         gen_helper_fsts_ST0(cpu_tmp2_i32, cpu_env);
5814                         tcg_gen_qemu_st_i32(cpu_tmp2_i32, cpu_A0,
5815                                             s->mem_index, MO_LEUL);
5816                         break;
5817                     case 1:
5818                         gen_helper_fistl_ST0(cpu_tmp2_i32, cpu_env);
5819                         tcg_gen_qemu_st_i32(cpu_tmp2_i32, cpu_A0,
5820                                             s->mem_index, MO_LEUL);
5821                         break;
5822                     case 2:
5823                         gen_helper_fstl_ST0(cpu_tmp1_i64, cpu_env);
5824                         tcg_gen_qemu_st_i64(cpu_tmp1_i64, cpu_A0,
5825                                             s->mem_index, MO_LEQ);
5826                         break;
5827                     case 3:
5828                     default:
5829                         gen_helper_fist_ST0(cpu_tmp2_i32, cpu_env);
5830                         tcg_gen_qemu_st_i32(cpu_tmp2_i32, cpu_A0,
5831                                             s->mem_index, MO_LEUW);
5832                         break;
5833                     }
5834                     if ((op & 7) == 3)
5835                         gen_helper_fpop(cpu_env);
5836                     break;
5837                 }
5838                 break;
5839             case 0x0c: /* fldenv mem */
5840                 gen_update_cc_op(s);
5841                 gen_jmp_im(pc_start - s->cs_base);
5842                 gen_helper_fldenv(cpu_env, cpu_A0, tcg_const_i32(dflag - 1));
5843                 break;
5844             case 0x0d: /* fldcw mem */
5845                 tcg_gen_qemu_ld_i32(cpu_tmp2_i32, cpu_A0,
5846                                     s->mem_index, MO_LEUW);
5847                 gen_helper_fldcw(cpu_env, cpu_tmp2_i32);
5848                 break;
5849             case 0x0e: /* fnstenv mem */
5850                 gen_update_cc_op(s);
5851                 gen_jmp_im(pc_start - s->cs_base);
5852                 gen_helper_fstenv(cpu_env, cpu_A0, tcg_const_i32(dflag - 1));
5853                 break;
5854             case 0x0f: /* fnstcw mem */
5855                 gen_helper_fnstcw(cpu_tmp2_i32, cpu_env);
5856                 tcg_gen_qemu_st_i32(cpu_tmp2_i32, cpu_A0,
5857                                     s->mem_index, MO_LEUW);
5858                 break;
5859             case 0x1d: /* fldt mem */
5860                 gen_update_cc_op(s);
5861                 gen_jmp_im(pc_start - s->cs_base);
5862                 gen_helper_fldt_ST0(cpu_env, cpu_A0);
5863                 break;
5864             case 0x1f: /* fstpt mem */
5865                 gen_update_cc_op(s);
5866                 gen_jmp_im(pc_start - s->cs_base);
5867                 gen_helper_fstt_ST0(cpu_env, cpu_A0);
5868                 gen_helper_fpop(cpu_env);
5869                 break;
5870             case 0x2c: /* frstor mem */
5871                 gen_update_cc_op(s);
5872                 gen_jmp_im(pc_start - s->cs_base);
5873                 gen_helper_frstor(cpu_env, cpu_A0, tcg_const_i32(dflag - 1));
5874                 break;
5875             case 0x2e: /* fnsave mem */
5876                 gen_update_cc_op(s);
5877                 gen_jmp_im(pc_start - s->cs_base);
5878                 gen_helper_fsave(cpu_env, cpu_A0, tcg_const_i32(dflag - 1));
5879                 break;
5880             case 0x2f: /* fnstsw mem */
5881                 gen_helper_fnstsw(cpu_tmp2_i32, cpu_env);
5882                 tcg_gen_qemu_st_i32(cpu_tmp2_i32, cpu_A0,
5883                                     s->mem_index, MO_LEUW);
5884                 break;
5885             case 0x3c: /* fbld */
5886                 gen_update_cc_op(s);
5887                 gen_jmp_im(pc_start - s->cs_base);
5888                 gen_helper_fbld_ST0(cpu_env, cpu_A0);
5889                 break;
5890             case 0x3e: /* fbstp */
5891                 gen_update_cc_op(s);
5892                 gen_jmp_im(pc_start - s->cs_base);
5893                 gen_helper_fbst_ST0(cpu_env, cpu_A0);
5894                 gen_helper_fpop(cpu_env);
5895                 break;
5896             case 0x3d: /* fildll */
5897                 tcg_gen_qemu_ld_i64(cpu_tmp1_i64, cpu_A0, s->mem_index, MO_LEQ);
5898                 gen_helper_fildll_ST0(cpu_env, cpu_tmp1_i64);
5899                 break;
5900             case 0x3f: /* fistpll */
5901                 gen_helper_fistll_ST0(cpu_tmp1_i64, cpu_env);
5902                 tcg_gen_qemu_st_i64(cpu_tmp1_i64, cpu_A0, s->mem_index, MO_LEQ);
5903                 gen_helper_fpop(cpu_env);
5904                 break;
5905             default:
5906                 goto illegal_op;
5907             }
5908         } else {
5909             /* register float ops */
5910             opreg = rm;
5911
5912             switch(op) {
5913             case 0x08: /* fld sti */
5914                 gen_helper_fpush(cpu_env);
5915                 gen_helper_fmov_ST0_STN(cpu_env,
5916                                         tcg_const_i32((opreg + 1) & 7));
5917                 break;
5918             case 0x09: /* fxchg sti */
5919             case 0x29: /* fxchg4 sti, undocumented op */
5920             case 0x39: /* fxchg7 sti, undocumented op */
5921                 gen_helper_fxchg_ST0_STN(cpu_env, tcg_const_i32(opreg));
5922                 break;
5923             case 0x0a: /* grp d9/2 */
5924                 switch(rm) {
5925                 case 0: /* fnop */
5926                     /* check exceptions (FreeBSD FPU probe) */
5927                     gen_update_cc_op(s);
5928                     gen_jmp_im(pc_start - s->cs_base);
5929                     gen_helper_fwait(cpu_env);
5930                     break;
5931                 default:
5932                     goto illegal_op;
5933                 }
5934                 break;
5935             case 0x0c: /* grp d9/4 */
5936                 switch(rm) {
5937                 case 0: /* fchs */
5938                     gen_helper_fchs_ST0(cpu_env);
5939                     break;
5940                 case 1: /* fabs */
5941                     gen_helper_fabs_ST0(cpu_env);
5942                     break;
5943                 case 4: /* ftst */
5944                     gen_helper_fldz_FT0(cpu_env);
5945                     gen_helper_fcom_ST0_FT0(cpu_env);
5946                     break;
5947                 case 5: /* fxam */
5948                     gen_helper_fxam_ST0(cpu_env);
5949                     break;
5950                 default:
5951                     goto illegal_op;
5952                 }
5953                 break;
5954             case 0x0d: /* grp d9/5 */
5955                 {
5956                     switch(rm) {
5957                     case 0:
5958                         gen_helper_fpush(cpu_env);
5959                         gen_helper_fld1_ST0(cpu_env);
5960                         break;
5961                     case 1:
5962                         gen_helper_fpush(cpu_env);
5963                         gen_helper_fldl2t_ST0(cpu_env);
5964                         break;
5965                     case 2:
5966                         gen_helper_fpush(cpu_env);
5967                         gen_helper_fldl2e_ST0(cpu_env);
5968                         break;
5969                     case 3:
5970                         gen_helper_fpush(cpu_env);
5971                         gen_helper_fldpi_ST0(cpu_env);
5972                         break;
5973                     case 4:
5974                         gen_helper_fpush(cpu_env);
5975                         gen_helper_fldlg2_ST0(cpu_env);
5976                         break;
5977                     case 5:
5978                         gen_helper_fpush(cpu_env);
5979                         gen_helper_fldln2_ST0(cpu_env);
5980                         break;
5981                     case 6:
5982                         gen_helper_fpush(cpu_env);
5983                         gen_helper_fldz_ST0(cpu_env);
5984                         break;
5985                     default:
5986                         goto illegal_op;
5987                     }
5988                 }
5989                 break;
5990             case 0x0e: /* grp d9/6 */
5991                 switch(rm) {
5992                 case 0: /* f2xm1 */
5993                     gen_helper_f2xm1(cpu_env);
5994                     break;
5995                 case 1: /* fyl2x */
5996                     gen_helper_fyl2x(cpu_env);
5997                     break;
5998                 case 2: /* fptan */
5999                     gen_helper_fptan(cpu_env);
6000                     break;
6001                 case 3: /* fpatan */
6002                     gen_helper_fpatan(cpu_env);
6003                     break;
6004                 case 4: /* fxtract */
6005                     gen_helper_fxtract(cpu_env);
6006                     break;
6007                 case 5: /* fprem1 */
6008                     gen_helper_fprem1(cpu_env);
6009                     break;
6010                 case 6: /* fdecstp */
6011                     gen_helper_fdecstp(cpu_env);
6012                     break;
6013                 default:
6014                 case 7: /* fincstp */
6015                     gen_helper_fincstp(cpu_env);
6016                     break;
6017                 }
6018                 break;
6019             case 0x0f: /* grp d9/7 */
6020                 switch(rm) {
6021                 case 0: /* fprem */
6022                     gen_helper_fprem(cpu_env);
6023                     break;
6024                 case 1: /* fyl2xp1 */
6025                     gen_helper_fyl2xp1(cpu_env);
6026                     break;
6027                 case 2: /* fsqrt */
6028                     gen_helper_fsqrt(cpu_env);
6029                     break;
6030                 case 3: /* fsincos */
6031                     gen_helper_fsincos(cpu_env);
6032                     break;
6033                 case 5: /* fscale */
6034                     gen_helper_fscale(cpu_env);
6035                     break;
6036                 case 4: /* frndint */
6037                     gen_helper_frndint(cpu_env);
6038                     break;
6039                 case 6: /* fsin */
6040                     gen_helper_fsin(cpu_env);
6041                     break;
6042                 default:
6043                 case 7: /* fcos */
6044                     gen_helper_fcos(cpu_env);
6045                     break;
6046                 }
6047                 break;
6048             case 0x00: case 0x01: case 0x04 ... 0x07: /* fxxx st, sti */
6049             case 0x20: case 0x21: case 0x24 ... 0x27: /* fxxx sti, st */
6050             case 0x30: case 0x31: case 0x34 ... 0x37: /* fxxxp sti, st */
6051                 {
6052                     int op1;
6053
6054                     op1 = op & 7;
6055                     if (op >= 0x20) {
6056                         gen_helper_fp_arith_STN_ST0(op1, opreg);
6057                         if (op >= 0x30)
6058                             gen_helper_fpop(cpu_env);
6059                     } else {
6060                         gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
6061                         gen_helper_fp_arith_ST0_FT0(op1);
6062                     }
6063                 }
6064                 break;
6065             case 0x02: /* fcom */
6066             case 0x22: /* fcom2, undocumented op */
6067                 gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
6068                 gen_helper_fcom_ST0_FT0(cpu_env);
6069                 break;
6070             case 0x03: /* fcomp */
6071             case 0x23: /* fcomp3, undocumented op */
6072             case 0x32: /* fcomp5, undocumented op */
6073                 gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
6074                 gen_helper_fcom_ST0_FT0(cpu_env);
6075                 gen_helper_fpop(cpu_env);
6076                 break;
6077             case 0x15: /* da/5 */
6078                 switch(rm) {
6079                 case 1: /* fucompp */
6080                     gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(1));
6081                     gen_helper_fucom_ST0_FT0(cpu_env);
6082                     gen_helper_fpop(cpu_env);
6083                     gen_helper_fpop(cpu_env);
6084                     break;
6085                 default:
6086                     goto illegal_op;
6087                 }
6088                 break;
6089             case 0x1c:
6090                 switch(rm) {
6091                 case 0: /* feni (287 only, just do nop here) */
6092                     break;
6093                 case 1: /* fdisi (287 only, just do nop here) */
6094                     break;
6095                 case 2: /* fclex */
6096                     gen_helper_fclex(cpu_env);
6097                     break;
6098                 case 3: /* fninit */
6099                     gen_helper_fninit(cpu_env);
6100                     break;
6101                 case 4: /* fsetpm (287 only, just do nop here) */
6102                     break;
6103                 default:
6104                     goto illegal_op;
6105                 }
6106                 break;
6107             case 0x1d: /* fucomi */
6108                 if (!(s->cpuid_features & CPUID_CMOV)) {
6109                     goto illegal_op;
6110                 }
6111                 gen_update_cc_op(s);
6112                 gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
6113                 gen_helper_fucomi_ST0_FT0(cpu_env);
6114                 set_cc_op(s, CC_OP_EFLAGS);
6115                 break;
6116             case 0x1e: /* fcomi */
6117                 if (!(s->cpuid_features & CPUID_CMOV)) {
6118                     goto illegal_op;
6119                 }
6120                 gen_update_cc_op(s);
6121                 gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
6122                 gen_helper_fcomi_ST0_FT0(cpu_env);
6123                 set_cc_op(s, CC_OP_EFLAGS);
6124                 break;
6125             case 0x28: /* ffree sti */
6126                 gen_helper_ffree_STN(cpu_env, tcg_const_i32(opreg));
6127                 break;
6128             case 0x2a: /* fst sti */
6129                 gen_helper_fmov_STN_ST0(cpu_env, tcg_const_i32(opreg));
6130                 break;
6131             case 0x2b: /* fstp sti */
6132             case 0x0b: /* fstp1 sti, undocumented op */
6133             case 0x3a: /* fstp8 sti, undocumented op */
6134             case 0x3b: /* fstp9 sti, undocumented op */
6135                 gen_helper_fmov_STN_ST0(cpu_env, tcg_const_i32(opreg));
6136                 gen_helper_fpop(cpu_env);
6137                 break;
6138             case 0x2c: /* fucom st(i) */
6139                 gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
6140                 gen_helper_fucom_ST0_FT0(cpu_env);
6141                 break;
6142             case 0x2d: /* fucomp st(i) */
6143                 gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
6144                 gen_helper_fucom_ST0_FT0(cpu_env);
6145                 gen_helper_fpop(cpu_env);
6146                 break;
6147             case 0x33: /* de/3 */
6148                 switch(rm) {
6149                 case 1: /* fcompp */
6150                     gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(1));
6151                     gen_helper_fcom_ST0_FT0(cpu_env);
6152                     gen_helper_fpop(cpu_env);
6153                     gen_helper_fpop(cpu_env);
6154                     break;
6155                 default:
6156                     goto illegal_op;
6157                 }
6158                 break;
6159             case 0x38: /* ffreep sti, undocumented op */
6160                 gen_helper_ffree_STN(cpu_env, tcg_const_i32(opreg));
6161                 gen_helper_fpop(cpu_env);
6162                 break;
6163             case 0x3c: /* df/4 */
6164                 switch(rm) {
6165                 case 0:
6166                     gen_helper_fnstsw(cpu_tmp2_i32, cpu_env);
6167                     tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
6168                     gen_op_mov_reg_v(MO_16, R_EAX, cpu_T[0]);
6169                     break;
6170                 default:
6171                     goto illegal_op;
6172                 }
6173                 break;
6174             case 0x3d: /* fucomip */
6175                 if (!(s->cpuid_features & CPUID_CMOV)) {
6176                     goto illegal_op;
6177                 }
6178                 gen_update_cc_op(s);
6179                 gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
6180                 gen_helper_fucomi_ST0_FT0(cpu_env);
6181                 gen_helper_fpop(cpu_env);
6182                 set_cc_op(s, CC_OP_EFLAGS);
6183                 break;
6184             case 0x3e: /* fcomip */
6185                 if (!(s->cpuid_features & CPUID_CMOV)) {
6186                     goto illegal_op;
6187                 }
6188                 gen_update_cc_op(s);
6189                 gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
6190                 gen_helper_fcomi_ST0_FT0(cpu_env);
6191                 gen_helper_fpop(cpu_env);
6192                 set_cc_op(s, CC_OP_EFLAGS);
6193                 break;
6194             case 0x10 ... 0x13: /* fcmovxx */
6195             case 0x18 ... 0x1b:
6196                 {
6197                     int op1, l1;
6198                     static const uint8_t fcmov_cc[8] = {
6199                         (JCC_B << 1),
6200                         (JCC_Z << 1),
6201                         (JCC_BE << 1),
6202                         (JCC_P << 1),
6203                     };
6204
6205                     if (!(s->cpuid_features & CPUID_CMOV)) {
6206                         goto illegal_op;
6207                     }
6208                     op1 = fcmov_cc[op & 3] | (((op >> 3) & 1) ^ 1);
6209                     l1 = gen_new_label();
6210                     gen_jcc1_noeob(s, op1, l1);
6211                     gen_helper_fmov_ST0_STN(cpu_env, tcg_const_i32(opreg));
6212                     gen_set_label(l1);
6213                 }
6214                 break;
6215             default:
6216                 goto illegal_op;
6217             }
6218         }
6219         break;
6220         /************************/
6221         /* string ops */
6222
6223     case 0xa4: /* movsS */
6224     case 0xa5:
6225         ot = mo_b_d(b, dflag);
6226         if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
6227             gen_repz_movs(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
6228         } else {
6229             gen_movs(s, ot);
6230         }
6231         break;
6232
6233     case 0xaa: /* stosS */
6234     case 0xab:
6235         ot = mo_b_d(b, dflag);
6236         if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
6237             gen_repz_stos(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
6238         } else {
6239             gen_stos(s, ot);
6240         }
6241         break;
6242     case 0xac: /* lodsS */
6243     case 0xad:
6244         ot = mo_b_d(b, dflag);
6245         if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
6246             gen_repz_lods(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
6247         } else {
6248             gen_lods(s, ot);
6249         }
6250         break;
6251     case 0xae: /* scasS */
6252     case 0xaf:
6253         ot = mo_b_d(b, dflag);
6254         if (prefixes & PREFIX_REPNZ) {
6255             gen_repz_scas(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 1);
6256         } else if (prefixes & PREFIX_REPZ) {
6257             gen_repz_scas(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 0);
6258         } else {
6259             gen_scas(s, ot);
6260         }
6261         break;
6262
6263     case 0xa6: /* cmpsS */
6264     case 0xa7:
6265         ot = mo_b_d(b, dflag);
6266         if (prefixes & PREFIX_REPNZ) {
6267             gen_repz_cmps(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 1);
6268         } else if (prefixes & PREFIX_REPZ) {
6269             gen_repz_cmps(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 0);
6270         } else {
6271             gen_cmps(s, ot);
6272         }
6273         break;
6274     case 0x6c: /* insS */
6275     case 0x6d:
6276         ot = mo_b_d32(b, dflag);
6277         tcg_gen_ext16u_tl(cpu_T[0], cpu_regs[R_EDX]);
6278         gen_check_io(s, ot, pc_start - s->cs_base,
6279                      SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes) | 4);
6280         if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
6281             gen_repz_ins(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
6282         } else {
6283             gen_ins(s, ot);
6284             if (use_icount) {
6285                 gen_jmp(s, s->pc - s->cs_base);
6286             }
6287         }
6288         break;
6289     case 0x6e: /* outsS */
6290     case 0x6f:
6291         ot = mo_b_d32(b, dflag);
6292         tcg_gen_ext16u_tl(cpu_T[0], cpu_regs[R_EDX]);
6293         gen_check_io(s, ot, pc_start - s->cs_base,
6294                      svm_is_rep(prefixes) | 4);
6295         if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
6296             gen_repz_outs(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
6297         } else {
6298             gen_outs(s, ot);
6299             if (use_icount) {
6300                 gen_jmp(s, s->pc - s->cs_base);
6301             }
6302         }
6303         break;
6304
6305         /************************/
6306         /* port I/O */
6307
6308     case 0xe4:
6309     case 0xe5:
6310         ot = mo_b_d32(b, dflag);
6311         val = cpu_ldub_code(env, s->pc++);
6312         tcg_gen_movi_tl(cpu_T[0], val);
6313         gen_check_io(s, ot, pc_start - s->cs_base,
6314                      SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes));
6315         if (use_icount)
6316             gen_io_start();
6317         tcg_gen_movi_i32(cpu_tmp2_i32, val);
6318         gen_helper_in_func(ot, cpu_T[1], cpu_tmp2_i32);
6319         gen_op_mov_reg_v(ot, R_EAX, cpu_T[1]);
6320         if (use_icount) {
6321             gen_io_end();
6322             gen_jmp(s, s->pc - s->cs_base);
6323         }
6324         break;
6325     case 0xe6:
6326     case 0xe7:
6327         ot = mo_b_d32(b, dflag);
6328         val = cpu_ldub_code(env, s->pc++);
6329         tcg_gen_movi_tl(cpu_T[0], val);
6330         gen_check_io(s, ot, pc_start - s->cs_base,
6331                      svm_is_rep(prefixes));
6332         gen_op_mov_v_reg(ot, cpu_T[1], R_EAX);
6333
6334         if (use_icount)
6335             gen_io_start();
6336         tcg_gen_movi_i32(cpu_tmp2_i32, val);
6337         tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[1]);
6338         gen_helper_out_func(ot, cpu_tmp2_i32, cpu_tmp3_i32);
6339         if (use_icount) {
6340             gen_io_end();
6341             gen_jmp(s, s->pc - s->cs_base);
6342         }
6343         break;
6344     case 0xec:
6345     case 0xed:
6346         ot = mo_b_d32(b, dflag);
6347         tcg_gen_ext16u_tl(cpu_T[0], cpu_regs[R_EDX]);
6348         gen_check_io(s, ot, pc_start - s->cs_base,
6349                      SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes));
6350         if (use_icount)
6351             gen_io_start();
6352         tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
6353         gen_helper_in_func(ot, cpu_T[1], cpu_tmp2_i32);
6354         gen_op_mov_reg_v(ot, R_EAX, cpu_T[1]);
6355         if (use_icount) {
6356             gen_io_end();
6357             gen_jmp(s, s->pc - s->cs_base);
6358         }
6359         break;
6360     case 0xee:
6361     case 0xef:
6362         ot = mo_b_d32(b, dflag);
6363         tcg_gen_ext16u_tl(cpu_T[0], cpu_regs[R_EDX]);
6364         gen_check_io(s, ot, pc_start - s->cs_base,
6365                      svm_is_rep(prefixes));
6366         gen_op_mov_v_reg(ot, cpu_T[1], R_EAX);
6367
6368         if (use_icount)
6369             gen_io_start();
6370         tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
6371         tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[1]);
6372         gen_helper_out_func(ot, cpu_tmp2_i32, cpu_tmp3_i32);
6373         if (use_icount) {
6374             gen_io_end();
6375             gen_jmp(s, s->pc - s->cs_base);
6376         }
6377         break;
6378
6379         /************************/
6380         /* control */
6381     case 0xc2: /* ret im */
6382         val = cpu_ldsw_code(env, s->pc);
6383         s->pc += 2;
6384         ot = gen_pop_T0(s);
6385         gen_stack_update(s, val + (1 << ot));
6386         /* Note that gen_pop_T0 uses a zero-extending load.  */
6387         gen_op_jmp_v(cpu_T[0]);
6388         gen_eob(s);
6389         break;
6390     case 0xc3: /* ret */
6391         ot = gen_pop_T0(s);
6392         gen_pop_update(s, ot);
6393         /* Note that gen_pop_T0 uses a zero-extending load.  */
6394         gen_op_jmp_v(cpu_T[0]);
6395         gen_eob(s);
6396         break;
6397     case 0xca: /* lret im */
6398         val = cpu_ldsw_code(env, s->pc);
6399         s->pc += 2;
6400     do_lret:
6401         if (s->pe && !s->vm86) {
6402             gen_update_cc_op(s);
6403             gen_jmp_im(pc_start - s->cs_base);
6404             gen_helper_lret_protected(cpu_env, tcg_const_i32(dflag - 1),
6405                                       tcg_const_i32(val));
6406         } else {
6407             gen_stack_A0(s);
6408             /* pop offset */
6409             gen_op_ld_v(s, dflag, cpu_T[0], cpu_A0);
6410             /* NOTE: keeping EIP updated is not a problem in case of
6411                exception */
6412             gen_op_jmp_v(cpu_T[0]);
6413             /* pop selector */
6414             gen_op_addl_A0_im(1 << dflag);
6415             gen_op_ld_v(s, dflag, cpu_T[0], cpu_A0);
6416             gen_op_movl_seg_T0_vm(R_CS);
6417             /* add stack offset */
6418             gen_stack_update(s, val + (2 << dflag));
6419         }
6420         gen_eob(s);
6421         break;
6422     case 0xcb: /* lret */
6423         val = 0;
6424         goto do_lret;
6425     case 0xcf: /* iret */
6426         gen_svm_check_intercept(s, pc_start, SVM_EXIT_IRET);
6427         if (!s->pe) {
6428             /* real mode */
6429             gen_helper_iret_real(cpu_env, tcg_const_i32(dflag - 1));
6430             set_cc_op(s, CC_OP_EFLAGS);
6431         } else if (s->vm86) {
6432             if (s->iopl != 3) {
6433                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6434             } else {
6435                 gen_helper_iret_real(cpu_env, tcg_const_i32(dflag - 1));
6436                 set_cc_op(s, CC_OP_EFLAGS);
6437             }
6438         } else {
6439             gen_update_cc_op(s);
6440             gen_jmp_im(pc_start - s->cs_base);
6441             gen_helper_iret_protected(cpu_env, tcg_const_i32(dflag - 1),
6442                                       tcg_const_i32(s->pc - s->cs_base));
6443             set_cc_op(s, CC_OP_EFLAGS);
6444         }
6445         gen_eob(s);
6446         break;
6447     case 0xe8: /* call im */
6448         {
6449             if (dflag != MO_16) {
6450                 tval = (int32_t)insn_get(env, s, MO_32);
6451             } else {
6452                 tval = (int16_t)insn_get(env, s, MO_16);
6453             }
6454             next_eip = s->pc - s->cs_base;
6455             tval += next_eip;
6456             if (dflag == MO_16) {
6457                 tval &= 0xffff;
6458             } else if (!CODE64(s)) {
6459                 tval &= 0xffffffff;
6460             }
6461             tcg_gen_movi_tl(cpu_T[0], next_eip);
6462             gen_push_v(s, cpu_T[0]);
6463             gen_jmp(s, tval);
6464         }
6465         break;
6466     case 0x9a: /* lcall im */
6467         {
6468             unsigned int selector, offset;
6469
6470             if (CODE64(s))
6471                 goto illegal_op;
6472             ot = dflag;
6473             offset = insn_get(env, s, ot);
6474             selector = insn_get(env, s, MO_16);
6475
6476             tcg_gen_movi_tl(cpu_T[0], selector);
6477             tcg_gen_movi_tl(cpu_T[1], offset);
6478         }
6479         goto do_lcall;
6480     case 0xe9: /* jmp im */
6481         if (dflag != MO_16) {
6482             tval = (int32_t)insn_get(env, s, MO_32);
6483         } else {
6484             tval = (int16_t)insn_get(env, s, MO_16);
6485         }
6486         tval += s->pc - s->cs_base;
6487         if (dflag == MO_16) {
6488             tval &= 0xffff;
6489         } else if (!CODE64(s)) {
6490             tval &= 0xffffffff;
6491         }
6492         gen_jmp(s, tval);
6493         break;
6494     case 0xea: /* ljmp im */
6495         {
6496             unsigned int selector, offset;
6497
6498             if (CODE64(s))
6499                 goto illegal_op;
6500             ot = dflag;
6501             offset = insn_get(env, s, ot);
6502             selector = insn_get(env, s, MO_16);
6503
6504             tcg_gen_movi_tl(cpu_T[0], selector);
6505             tcg_gen_movi_tl(cpu_T[1], offset);
6506         }
6507         goto do_ljmp;
6508     case 0xeb: /* jmp Jb */
6509         tval = (int8_t)insn_get(env, s, MO_8);
6510         tval += s->pc - s->cs_base;
6511         if (dflag == MO_16) {
6512             tval &= 0xffff;
6513         }
6514         gen_jmp(s, tval);
6515         break;
6516     case 0x70 ... 0x7f: /* jcc Jb */
6517         tval = (int8_t)insn_get(env, s, MO_8);
6518         goto do_jcc;
6519     case 0x180 ... 0x18f: /* jcc Jv */
6520         if (dflag != MO_16) {
6521             tval = (int32_t)insn_get(env, s, MO_32);
6522         } else {
6523             tval = (int16_t)insn_get(env, s, MO_16);
6524         }
6525     do_jcc:
6526         next_eip = s->pc - s->cs_base;
6527         tval += next_eip;
6528         if (dflag == MO_16) {
6529             tval &= 0xffff;
6530         }
6531         gen_jcc(s, b, tval, next_eip);
6532         break;
6533
6534     case 0x190 ... 0x19f: /* setcc Gv */
6535         modrm = cpu_ldub_code(env, s->pc++);
6536         gen_setcc1(s, b, cpu_T[0]);
6537         gen_ldst_modrm(env, s, modrm, MO_8, OR_TMP0, 1);
6538         break;
6539     case 0x140 ... 0x14f: /* cmov Gv, Ev */
6540         if (!(s->cpuid_features & CPUID_CMOV)) {
6541             goto illegal_op;
6542         }
6543         ot = dflag;
6544         modrm = cpu_ldub_code(env, s->pc++);
6545         reg = ((modrm >> 3) & 7) | rex_r;
6546         gen_cmovcc1(env, s, ot, b, modrm, reg);
6547         break;
6548
6549         /************************/
6550         /* flags */
6551     case 0x9c: /* pushf */
6552         gen_svm_check_intercept(s, pc_start, SVM_EXIT_PUSHF);
6553         if (s->vm86 && s->iopl != 3) {
6554             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6555         } else {
6556             gen_update_cc_op(s);
6557             gen_helper_read_eflags(cpu_T[0], cpu_env);
6558             gen_push_v(s, cpu_T[0]);
6559         }
6560         break;
6561     case 0x9d: /* popf */
6562         gen_svm_check_intercept(s, pc_start, SVM_EXIT_POPF);
6563         if (s->vm86 && s->iopl != 3) {
6564             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6565         } else {
6566             ot = gen_pop_T0(s);
6567             if (s->cpl == 0) {
6568                 if (dflag != MO_16) {
6569                     gen_helper_write_eflags(cpu_env, cpu_T[0],
6570                                             tcg_const_i32((TF_MASK | AC_MASK |
6571                                                            ID_MASK | NT_MASK |
6572                                                            IF_MASK |
6573                                                            IOPL_MASK)));
6574                 } else {
6575                     gen_helper_write_eflags(cpu_env, cpu_T[0],
6576                                             tcg_const_i32((TF_MASK | AC_MASK |
6577                                                            ID_MASK | NT_MASK |
6578                                                            IF_MASK | IOPL_MASK)
6579                                                           & 0xffff));
6580                 }
6581             } else {
6582                 if (s->cpl <= s->iopl) {
6583                     if (dflag != MO_16) {
6584                         gen_helper_write_eflags(cpu_env, cpu_T[0],
6585                                                 tcg_const_i32((TF_MASK |
6586                                                                AC_MASK |
6587                                                                ID_MASK |
6588                                                                NT_MASK |
6589                                                                IF_MASK)));
6590                     } else {
6591                         gen_helper_write_eflags(cpu_env, cpu_T[0],
6592                                                 tcg_const_i32((TF_MASK |
6593                                                                AC_MASK |
6594                                                                ID_MASK |
6595                                                                NT_MASK |
6596                                                                IF_MASK)
6597                                                               & 0xffff));
6598                     }
6599                 } else {
6600                     if (dflag != MO_16) {
6601                         gen_helper_write_eflags(cpu_env, cpu_T[0],
6602                                            tcg_const_i32((TF_MASK | AC_MASK |
6603                                                           ID_MASK | NT_MASK)));
6604                     } else {
6605                         gen_helper_write_eflags(cpu_env, cpu_T[0],
6606                                            tcg_const_i32((TF_MASK | AC_MASK |
6607                                                           ID_MASK | NT_MASK)
6608                                                          & 0xffff));
6609                     }
6610                 }
6611             }
6612             gen_pop_update(s, ot);
6613             set_cc_op(s, CC_OP_EFLAGS);
6614             /* abort translation because TF/AC flag may change */
6615             gen_jmp_im(s->pc - s->cs_base);
6616             gen_eob(s);
6617         }
6618         break;
6619     case 0x9e: /* sahf */
6620         if (CODE64(s) && !(s->cpuid_ext3_features & CPUID_EXT3_LAHF_LM))
6621             goto illegal_op;
6622         gen_op_mov_v_reg(MO_8, cpu_T[0], R_AH);
6623         gen_compute_eflags(s);
6624         tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, CC_O);
6625         tcg_gen_andi_tl(cpu_T[0], cpu_T[0], CC_S | CC_Z | CC_A | CC_P | CC_C);
6626         tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, cpu_T[0]);
6627         break;
6628     case 0x9f: /* lahf */
6629         if (CODE64(s) && !(s->cpuid_ext3_features & CPUID_EXT3_LAHF_LM))
6630             goto illegal_op;
6631         gen_compute_eflags(s);
6632         /* Note: gen_compute_eflags() only gives the condition codes */
6633         tcg_gen_ori_tl(cpu_T[0], cpu_cc_src, 0x02);
6634         gen_op_mov_reg_v(MO_8, R_AH, cpu_T[0]);
6635         break;
6636     case 0xf5: /* cmc */
6637         gen_compute_eflags(s);
6638         tcg_gen_xori_tl(cpu_cc_src, cpu_cc_src, CC_C);
6639         break;
6640     case 0xf8: /* clc */
6641         gen_compute_eflags(s);
6642         tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, ~CC_C);
6643         break;
6644     case 0xf9: /* stc */
6645         gen_compute_eflags(s);
6646         tcg_gen_ori_tl(cpu_cc_src, cpu_cc_src, CC_C);
6647         break;
6648     case 0xfc: /* cld */
6649         tcg_gen_movi_i32(cpu_tmp2_i32, 1);
6650         tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, offsetof(CPUX86State, df));
6651         break;
6652     case 0xfd: /* std */
6653         tcg_gen_movi_i32(cpu_tmp2_i32, -1);
6654         tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, offsetof(CPUX86State, df));
6655         break;
6656
6657         /************************/
6658         /* bit operations */
6659     case 0x1ba: /* bt/bts/btr/btc Gv, im */
6660         ot = dflag;
6661         modrm = cpu_ldub_code(env, s->pc++);
6662         op = (modrm >> 3) & 7;
6663         mod = (modrm >> 6) & 3;
6664         rm = (modrm & 7) | REX_B(s);
6665         if (mod != 3) {
6666             s->rip_offset = 1;
6667             gen_lea_modrm(env, s, modrm);
6668             gen_op_ld_v(s, ot, cpu_T[0], cpu_A0);
6669         } else {
6670             gen_op_mov_v_reg(ot, cpu_T[0], rm);
6671         }
6672         /* load shift */
6673         val = cpu_ldub_code(env, s->pc++);
6674         tcg_gen_movi_tl(cpu_T[1], val);
6675         if (op < 4)
6676             goto illegal_op;
6677         op -= 4;
6678         goto bt_op;
6679     case 0x1a3: /* bt Gv, Ev */
6680         op = 0;
6681         goto do_btx;
6682     case 0x1ab: /* bts */
6683         op = 1;
6684         goto do_btx;
6685     case 0x1b3: /* btr */
6686         op = 2;
6687         goto do_btx;
6688     case 0x1bb: /* btc */
6689         op = 3;
6690     do_btx:
6691         ot = dflag;
6692         modrm = cpu_ldub_code(env, s->pc++);
6693         reg = ((modrm >> 3) & 7) | rex_r;
6694         mod = (modrm >> 6) & 3;
6695         rm = (modrm & 7) | REX_B(s);
6696         gen_op_mov_v_reg(MO_32, cpu_T[1], reg);
6697         if (mod != 3) {
6698             gen_lea_modrm(env, s, modrm);
6699             /* specific case: we need to add a displacement */
6700             gen_exts(ot, cpu_T[1]);
6701             tcg_gen_sari_tl(cpu_tmp0, cpu_T[1], 3 + ot);
6702             tcg_gen_shli_tl(cpu_tmp0, cpu_tmp0, ot);
6703             tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
6704             gen_op_ld_v(s, ot, cpu_T[0], cpu_A0);
6705         } else {
6706             gen_op_mov_v_reg(ot, cpu_T[0], rm);
6707         }
6708     bt_op:
6709         tcg_gen_andi_tl(cpu_T[1], cpu_T[1], (1 << (3 + ot)) - 1);
6710         tcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);
6711         switch(op) {
6712         case 0:
6713             break;
6714         case 1:
6715             tcg_gen_movi_tl(cpu_tmp0, 1);
6716             tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);
6717             tcg_gen_or_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
6718             break;
6719         case 2:
6720             tcg_gen_movi_tl(cpu_tmp0, 1);
6721             tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);
6722             tcg_gen_andc_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
6723             break;
6724         default:
6725         case 3:
6726             tcg_gen_movi_tl(cpu_tmp0, 1);
6727             tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);
6728             tcg_gen_xor_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
6729             break;
6730         }
6731         if (op != 0) {
6732             if (mod != 3) {
6733                 gen_op_st_v(s, ot, cpu_T[0], cpu_A0);
6734             } else {
6735                 gen_op_mov_reg_v(ot, rm, cpu_T[0]);
6736             }
6737         }
6738
6739         /* Delay all CC updates until after the store above.  Note that
6740            C is the result of the test, Z is unchanged, and the others
6741            are all undefined.  */
6742         switch (s->cc_op) {
6743         case CC_OP_MULB ... CC_OP_MULQ:
6744         case CC_OP_ADDB ... CC_OP_ADDQ:
6745         case CC_OP_ADCB ... CC_OP_ADCQ:
6746         case CC_OP_SUBB ... CC_OP_SUBQ:
6747         case CC_OP_SBBB ... CC_OP_SBBQ:
6748         case CC_OP_LOGICB ... CC_OP_LOGICQ:
6749         case CC_OP_INCB ... CC_OP_INCQ:
6750         case CC_OP_DECB ... CC_OP_DECQ:
6751         case CC_OP_SHLB ... CC_OP_SHLQ:
6752         case CC_OP_SARB ... CC_OP_SARQ:
6753         case CC_OP_BMILGB ... CC_OP_BMILGQ:
6754             /* Z was going to be computed from the non-zero status of CC_DST.
6755                We can get that same Z value (and the new C value) by leaving
6756                CC_DST alone, setting CC_SRC, and using a CC_OP_SAR of the
6757                same width.  */
6758             tcg_gen_mov_tl(cpu_cc_src, cpu_tmp4);
6759             set_cc_op(s, ((s->cc_op - CC_OP_MULB) & 3) + CC_OP_SARB);
6760             break;
6761         default:
6762             /* Otherwise, generate EFLAGS and replace the C bit.  */
6763             gen_compute_eflags(s);
6764             tcg_gen_deposit_tl(cpu_cc_src, cpu_cc_src, cpu_tmp4,
6765                                ctz32(CC_C), 1);
6766             break;
6767         }
6768         break;
6769     case 0x1bc: /* bsf / tzcnt */
6770     case 0x1bd: /* bsr / lzcnt */
6771         ot = dflag;
6772         modrm = cpu_ldub_code(env, s->pc++);
6773         reg = ((modrm >> 3) & 7) | rex_r;
6774         gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
6775         gen_extu(ot, cpu_T[0]);
6776
6777         /* Note that lzcnt and tzcnt are in different extensions.  */
6778         if ((prefixes & PREFIX_REPZ)
6779             && (b & 1
6780                 ? s->cpuid_ext3_features & CPUID_EXT3_ABM
6781                 : s->cpuid_7_0_ebx_features & CPUID_7_0_EBX_BMI1)) {
6782             int size = 8 << ot;
6783             tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
6784             if (b & 1) {
6785                 /* For lzcnt, reduce the target_ulong result by the
6786                    number of zeros that we expect to find at the top.  */
6787                 gen_helper_clz(cpu_T[0], cpu_T[0]);
6788                 tcg_gen_subi_tl(cpu_T[0], cpu_T[0], TARGET_LONG_BITS - size);
6789             } else {
6790                 /* For tzcnt, a zero input must return the operand size:
6791                    force all bits outside the operand size to 1.  */
6792                 target_ulong mask = (target_ulong)-2 << (size - 1);
6793                 tcg_gen_ori_tl(cpu_T[0], cpu_T[0], mask);
6794                 gen_helper_ctz(cpu_T[0], cpu_T[0]);
6795             }
6796             /* For lzcnt/tzcnt, C and Z bits are defined and are
6797                related to the result.  */
6798             gen_op_update1_cc();
6799             set_cc_op(s, CC_OP_BMILGB + ot);
6800         } else {
6801             /* For bsr/bsf, only the Z bit is defined and it is related
6802                to the input and not the result.  */
6803             tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
6804             set_cc_op(s, CC_OP_LOGICB + ot);
6805             if (b & 1) {
6806                 /* For bsr, return the bit index of the first 1 bit,
6807                    not the count of leading zeros.  */
6808                 gen_helper_clz(cpu_T[0], cpu_T[0]);
6809                 tcg_gen_xori_tl(cpu_T[0], cpu_T[0], TARGET_LONG_BITS - 1);
6810             } else {
6811                 gen_helper_ctz(cpu_T[0], cpu_T[0]);
6812             }
6813             /* ??? The manual says that the output is undefined when the
6814                input is zero, but real hardware leaves it unchanged, and
6815                real programs appear to depend on that.  */
6816             tcg_gen_movi_tl(cpu_tmp0, 0);
6817             tcg_gen_movcond_tl(TCG_COND_EQ, cpu_T[0], cpu_cc_dst, cpu_tmp0,
6818                                cpu_regs[reg], cpu_T[0]);
6819         }
6820         gen_op_mov_reg_v(ot, reg, cpu_T[0]);
6821         break;
6822         /************************/
6823         /* bcd */
6824     case 0x27: /* daa */
6825         if (CODE64(s))
6826             goto illegal_op;
6827         gen_update_cc_op(s);
6828         gen_helper_daa(cpu_env);
6829         set_cc_op(s, CC_OP_EFLAGS);
6830         break;
6831     case 0x2f: /* das */
6832         if (CODE64(s))
6833             goto illegal_op;
6834         gen_update_cc_op(s);
6835         gen_helper_das(cpu_env);
6836         set_cc_op(s, CC_OP_EFLAGS);
6837         break;
6838     case 0x37: /* aaa */
6839         if (CODE64(s))
6840             goto illegal_op;
6841         gen_update_cc_op(s);
6842         gen_helper_aaa(cpu_env);
6843         set_cc_op(s, CC_OP_EFLAGS);
6844         break;
6845     case 0x3f: /* aas */
6846         if (CODE64(s))
6847             goto illegal_op;
6848         gen_update_cc_op(s);
6849         gen_helper_aas(cpu_env);
6850         set_cc_op(s, CC_OP_EFLAGS);
6851         break;
6852     case 0xd4: /* aam */
6853         if (CODE64(s))
6854             goto illegal_op;
6855         val = cpu_ldub_code(env, s->pc++);
6856         if (val == 0) {
6857             gen_exception(s, EXCP00_DIVZ, pc_start - s->cs_base);
6858         } else {
6859             gen_helper_aam(cpu_env, tcg_const_i32(val));
6860             set_cc_op(s, CC_OP_LOGICB);
6861         }
6862         break;
6863     case 0xd5: /* aad */
6864         if (CODE64(s))
6865             goto illegal_op;
6866         val = cpu_ldub_code(env, s->pc++);
6867         gen_helper_aad(cpu_env, tcg_const_i32(val));
6868         set_cc_op(s, CC_OP_LOGICB);
6869         break;
6870         /************************/
6871         /* misc */
6872     case 0x90: /* nop */
6873         /* XXX: correct lock test for all insn */
6874         if (prefixes & PREFIX_LOCK) {
6875             goto illegal_op;
6876         }
6877         /* If REX_B is set, then this is xchg eax, r8d, not a nop.  */
6878         if (REX_B(s)) {
6879             goto do_xchg_reg_eax;
6880         }
6881         if (prefixes & PREFIX_REPZ) {
6882             gen_update_cc_op(s);
6883             gen_jmp_im(pc_start - s->cs_base);
6884             gen_helper_pause(cpu_env, tcg_const_i32(s->pc - pc_start));
6885             s->is_jmp = DISAS_TB_JUMP;
6886         }
6887         break;
6888     case 0x9b: /* fwait */
6889         if ((s->flags & (HF_MP_MASK | HF_TS_MASK)) ==
6890             (HF_MP_MASK | HF_TS_MASK)) {
6891             gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
6892         } else {
6893             gen_update_cc_op(s);
6894             gen_jmp_im(pc_start - s->cs_base);
6895             gen_helper_fwait(cpu_env);
6896         }
6897         break;
6898     case 0xcc: /* int3 */
6899         gen_interrupt(s, EXCP03_INT3, pc_start - s->cs_base, s->pc - s->cs_base);
6900         break;
6901     case 0xcd: /* int N */
6902         val = cpu_ldub_code(env, s->pc++);
6903         if (s->vm86 && s->iopl != 3) {
6904             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6905         } else {
6906             gen_interrupt(s, val, pc_start - s->cs_base, s->pc - s->cs_base);
6907         }
6908         break;
6909     case 0xce: /* into */
6910         if (CODE64(s))
6911             goto illegal_op;
6912         gen_update_cc_op(s);
6913         gen_jmp_im(pc_start - s->cs_base);
6914         gen_helper_into(cpu_env, tcg_const_i32(s->pc - pc_start));
6915         break;
6916 #ifdef WANT_ICEBP
6917     case 0xf1: /* icebp (undocumented, exits to external debugger) */
6918         gen_svm_check_intercept(s, pc_start, SVM_EXIT_ICEBP);
6919 #if 1
6920         gen_debug(s, pc_start - s->cs_base);
6921 #else
6922         /* start debug */
6923         tb_flush(env);
6924         qemu_set_log(CPU_LOG_INT | CPU_LOG_TB_IN_ASM);
6925 #endif
6926         break;
6927 #endif
6928     case 0xfa: /* cli */
6929         if (!s->vm86) {
6930             if (s->cpl <= s->iopl) {
6931                 gen_helper_cli(cpu_env);
6932             } else {
6933                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6934             }
6935         } else {
6936             if (s->iopl == 3) {
6937                 gen_helper_cli(cpu_env);
6938             } else {
6939                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6940             }
6941         }
6942         break;
6943     case 0xfb: /* sti */
6944         if (!s->vm86) {
6945             if (s->cpl <= s->iopl) {
6946             gen_sti:
6947                 gen_helper_sti(cpu_env);
6948                 /* interruptions are enabled only the first insn after sti */
6949                 /* If several instructions disable interrupts, only the
6950                    _first_ does it */
6951                 if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
6952                     gen_helper_set_inhibit_irq(cpu_env);
6953                 /* give a chance to handle pending irqs */
6954                 gen_jmp_im(s->pc - s->cs_base);
6955                 gen_eob(s);
6956             } else {
6957                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6958             }
6959         } else {
6960             if (s->iopl == 3) {
6961                 goto gen_sti;
6962             } else {
6963                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6964             }
6965         }
6966         break;
6967     case 0x62: /* bound */
6968         if (CODE64(s))
6969             goto illegal_op;
6970         ot = dflag;
6971         modrm = cpu_ldub_code(env, s->pc++);
6972         reg = (modrm >> 3) & 7;
6973         mod = (modrm >> 6) & 3;
6974         if (mod == 3)
6975             goto illegal_op;
6976         gen_op_mov_v_reg(ot, cpu_T[0], reg);
6977         gen_lea_modrm(env, s, modrm);
6978         gen_jmp_im(pc_start - s->cs_base);
6979         tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
6980         if (ot == MO_16) {
6981             gen_helper_boundw(cpu_env, cpu_A0, cpu_tmp2_i32);
6982         } else {
6983             gen_helper_boundl(cpu_env, cpu_A0, cpu_tmp2_i32);
6984         }
6985         break;
6986     case 0x1c8 ... 0x1cf: /* bswap reg */
6987         reg = (b & 7) | REX_B(s);
6988 #ifdef TARGET_X86_64
6989         if (dflag == MO_64) {
6990             gen_op_mov_v_reg(MO_64, cpu_T[0], reg);
6991             tcg_gen_bswap64_i64(cpu_T[0], cpu_T[0]);
6992             gen_op_mov_reg_v(MO_64, reg, cpu_T[0]);
6993         } else
6994 #endif
6995         {
6996             gen_op_mov_v_reg(MO_32, cpu_T[0], reg);
6997             tcg_gen_ext32u_tl(cpu_T[0], cpu_T[0]);
6998             tcg_gen_bswap32_tl(cpu_T[0], cpu_T[0]);
6999             gen_op_mov_reg_v(MO_32, reg, cpu_T[0]);
7000         }
7001         break;
7002     case 0xd6: /* salc */
7003         if (CODE64(s))
7004             goto illegal_op;
7005         gen_compute_eflags_c(s, cpu_T[0]);
7006         tcg_gen_neg_tl(cpu_T[0], cpu_T[0]);
7007         gen_op_mov_reg_v(MO_8, R_EAX, cpu_T[0]);
7008         break;
7009     case 0xe0: /* loopnz */
7010     case 0xe1: /* loopz */
7011     case 0xe2: /* loop */
7012     case 0xe3: /* jecxz */
7013         {
7014             int l1, l2, l3;
7015
7016             tval = (int8_t)insn_get(env, s, MO_8);
7017             next_eip = s->pc - s->cs_base;
7018             tval += next_eip;
7019             if (dflag == MO_16) {
7020                 tval &= 0xffff;
7021             }
7022
7023             l1 = gen_new_label();
7024             l2 = gen_new_label();
7025             l3 = gen_new_label();
7026             b &= 3;
7027             switch(b) {
7028             case 0: /* loopnz */
7029             case 1: /* loopz */
7030                 gen_op_add_reg_im(s->aflag, R_ECX, -1);
7031                 gen_op_jz_ecx(s->aflag, l3);
7032                 gen_jcc1(s, (JCC_Z << 1) | (b ^ 1), l1);
7033                 break;
7034             case 2: /* loop */
7035                 gen_op_add_reg_im(s->aflag, R_ECX, -1);
7036                 gen_op_jnz_ecx(s->aflag, l1);
7037                 break;
7038             default:
7039             case 3: /* jcxz */
7040                 gen_op_jz_ecx(s->aflag, l1);
7041                 break;
7042             }
7043
7044             gen_set_label(l3);
7045             gen_jmp_im(next_eip);
7046             tcg_gen_br(l2);
7047
7048             gen_set_label(l1);
7049             gen_jmp_im(tval);
7050             gen_set_label(l2);
7051             gen_eob(s);
7052         }
7053         break;
7054     case 0x130: /* wrmsr */
7055     case 0x132: /* rdmsr */
7056         if (s->cpl != 0) {
7057             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7058         } else {
7059             gen_update_cc_op(s);
7060             gen_jmp_im(pc_start - s->cs_base);
7061             if (b & 2) {
7062                 gen_helper_rdmsr(cpu_env);
7063             } else {
7064                 gen_helper_wrmsr(cpu_env);
7065             }
7066         }
7067         break;
7068     case 0x131: /* rdtsc */
7069         gen_update_cc_op(s);
7070         gen_jmp_im(pc_start - s->cs_base);
7071         if (use_icount)
7072             gen_io_start();
7073         gen_helper_rdtsc(cpu_env);
7074         if (use_icount) {
7075             gen_io_end();
7076             gen_jmp(s, s->pc - s->cs_base);
7077         }
7078         break;
7079     case 0x133: /* rdpmc */
7080         gen_update_cc_op(s);
7081         gen_jmp_im(pc_start - s->cs_base);
7082         gen_helper_rdpmc(cpu_env);
7083         break;
7084     case 0x134: /* sysenter */
7085         /* For Intel SYSENTER is valid on 64-bit */
7086         if (CODE64(s) && env->cpuid_vendor1 != CPUID_VENDOR_INTEL_1)
7087             goto illegal_op;
7088         if (!s->pe) {
7089             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7090         } else {
7091             gen_update_cc_op(s);
7092             gen_jmp_im(pc_start - s->cs_base);
7093             gen_helper_sysenter(cpu_env);
7094             gen_eob(s);
7095         }
7096         break;
7097     case 0x135: /* sysexit */
7098         /* For Intel SYSEXIT is valid on 64-bit */
7099         if (CODE64(s) && env->cpuid_vendor1 != CPUID_VENDOR_INTEL_1)
7100             goto illegal_op;
7101         if (!s->pe) {
7102             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7103         } else {
7104             gen_update_cc_op(s);
7105             gen_jmp_im(pc_start - s->cs_base);
7106             gen_helper_sysexit(cpu_env, tcg_const_i32(dflag - 1));
7107             gen_eob(s);
7108         }
7109         break;
7110 #ifdef TARGET_X86_64
7111     case 0x105: /* syscall */
7112         /* XXX: is it usable in real mode ? */
7113         gen_update_cc_op(s);
7114         gen_jmp_im(pc_start - s->cs_base);
7115         gen_helper_syscall(cpu_env, tcg_const_i32(s->pc - pc_start));
7116         gen_eob(s);
7117         break;
7118     case 0x107: /* sysret */
7119         if (!s->pe) {
7120             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7121         } else {
7122             gen_update_cc_op(s);
7123             gen_jmp_im(pc_start - s->cs_base);
7124             gen_helper_sysret(cpu_env, tcg_const_i32(dflag - 1));
7125             /* condition codes are modified only in long mode */
7126             if (s->lma) {
7127                 set_cc_op(s, CC_OP_EFLAGS);
7128             }
7129             gen_eob(s);
7130         }
7131         break;
7132 #endif
7133     case 0x1a2: /* cpuid */
7134         gen_update_cc_op(s);
7135         gen_jmp_im(pc_start - s->cs_base);
7136         gen_helper_cpuid(cpu_env);
7137         break;
7138     case 0xf4: /* hlt */
7139         if (s->cpl != 0) {
7140             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7141         } else {
7142             gen_update_cc_op(s);
7143             gen_jmp_im(pc_start - s->cs_base);
7144             gen_helper_hlt(cpu_env, tcg_const_i32(s->pc - pc_start));
7145             s->is_jmp = DISAS_TB_JUMP;
7146         }
7147         break;
7148     case 0x100:
7149         modrm = cpu_ldub_code(env, s->pc++);
7150         mod = (modrm >> 6) & 3;
7151         op = (modrm >> 3) & 7;
7152         switch(op) {
7153         case 0: /* sldt */
7154             if (!s->pe || s->vm86)
7155                 goto illegal_op;
7156             gen_svm_check_intercept(s, pc_start, SVM_EXIT_LDTR_READ);
7157             tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,ldt.selector));
7158             ot = mod == 3 ? dflag : MO_16;
7159             gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 1);
7160             break;
7161         case 2: /* lldt */
7162             if (!s->pe || s->vm86)
7163                 goto illegal_op;
7164             if (s->cpl != 0) {
7165                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7166             } else {
7167                 gen_svm_check_intercept(s, pc_start, SVM_EXIT_LDTR_WRITE);
7168                 gen_ldst_modrm(env, s, modrm, MO_16, OR_TMP0, 0);
7169                 gen_jmp_im(pc_start - s->cs_base);
7170                 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
7171                 gen_helper_lldt(cpu_env, cpu_tmp2_i32);
7172             }
7173             break;
7174         case 1: /* str */
7175             if (!s->pe || s->vm86)
7176                 goto illegal_op;
7177             gen_svm_check_intercept(s, pc_start, SVM_EXIT_TR_READ);
7178             tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,tr.selector));
7179             ot = mod == 3 ? dflag : MO_16;
7180             gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 1);
7181             break;
7182         case 3: /* ltr */
7183             if (!s->pe || s->vm86)
7184                 goto illegal_op;
7185             if (s->cpl != 0) {
7186                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7187             } else {
7188                 gen_svm_check_intercept(s, pc_start, SVM_EXIT_TR_WRITE);
7189                 gen_ldst_modrm(env, s, modrm, MO_16, OR_TMP0, 0);
7190                 gen_jmp_im(pc_start - s->cs_base);
7191                 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
7192                 gen_helper_ltr(cpu_env, cpu_tmp2_i32);
7193             }
7194             break;
7195         case 4: /* verr */
7196         case 5: /* verw */
7197             if (!s->pe || s->vm86)
7198                 goto illegal_op;
7199             gen_ldst_modrm(env, s, modrm, MO_16, OR_TMP0, 0);
7200             gen_update_cc_op(s);
7201             if (op == 4) {
7202                 gen_helper_verr(cpu_env, cpu_T[0]);
7203             } else {
7204                 gen_helper_verw(cpu_env, cpu_T[0]);
7205             }
7206             set_cc_op(s, CC_OP_EFLAGS);
7207             break;
7208         default:
7209             goto illegal_op;
7210         }
7211         break;
7212     case 0x101:
7213         modrm = cpu_ldub_code(env, s->pc++);
7214         mod = (modrm >> 6) & 3;
7215         op = (modrm >> 3) & 7;
7216         rm = modrm & 7;
7217         switch(op) {
7218         case 0: /* sgdt */
7219             if (mod == 3)
7220                 goto illegal_op;
7221             gen_svm_check_intercept(s, pc_start, SVM_EXIT_GDTR_READ);
7222             gen_lea_modrm(env, s, modrm);
7223             tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, gdt.limit));
7224             gen_op_st_v(s, MO_16, cpu_T[0], cpu_A0);
7225             gen_add_A0_im(s, 2);
7226             tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, gdt.base));
7227             if (dflag == MO_16) {
7228                 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xffffff);
7229             }
7230             gen_op_st_v(s, CODE64(s) + MO_32, cpu_T[0], cpu_A0);
7231             break;
7232         case 1:
7233             if (mod == 3) {
7234                 switch (rm) {
7235                 case 0: /* monitor */
7236                     if (!(s->cpuid_ext_features & CPUID_EXT_MONITOR) ||
7237                         s->cpl != 0)
7238                         goto illegal_op;
7239                     gen_update_cc_op(s);
7240                     gen_jmp_im(pc_start - s->cs_base);
7241                     tcg_gen_mov_tl(cpu_A0, cpu_regs[R_EAX]);
7242                     gen_extu(s->aflag, cpu_A0);
7243                     gen_add_A0_ds_seg(s);
7244                     gen_helper_monitor(cpu_env, cpu_A0);
7245                     break;
7246                 case 1: /* mwait */
7247                     if (!(s->cpuid_ext_features & CPUID_EXT_MONITOR) ||
7248                         s->cpl != 0)
7249                         goto illegal_op;
7250                     gen_update_cc_op(s);
7251                     gen_jmp_im(pc_start - s->cs_base);
7252                     gen_helper_mwait(cpu_env, tcg_const_i32(s->pc - pc_start));
7253                     gen_eob(s);
7254                     break;
7255                 case 2: /* clac */
7256                     if (!(s->cpuid_7_0_ebx_features & CPUID_7_0_EBX_SMAP) ||
7257                         s->cpl != 0) {
7258                         goto illegal_op;
7259                     }
7260                     gen_helper_clac(cpu_env);
7261                     gen_jmp_im(s->pc - s->cs_base);
7262                     gen_eob(s);
7263                     break;
7264                 case 3: /* stac */
7265                     if (!(s->cpuid_7_0_ebx_features & CPUID_7_0_EBX_SMAP) ||
7266                         s->cpl != 0) {
7267                         goto illegal_op;
7268                     }
7269                     gen_helper_stac(cpu_env);
7270                     gen_jmp_im(s->pc - s->cs_base);
7271                     gen_eob(s);
7272                     break;
7273                 default:
7274                     goto illegal_op;
7275                 }
7276             } else { /* sidt */
7277                 gen_svm_check_intercept(s, pc_start, SVM_EXIT_IDTR_READ);
7278                 gen_lea_modrm(env, s, modrm);
7279                 tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, idt.limit));
7280                 gen_op_st_v(s, MO_16, cpu_T[0], cpu_A0);
7281                 gen_add_A0_im(s, 2);
7282                 tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, idt.base));
7283                 if (dflag == MO_16) {
7284                     tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xffffff);
7285                 }
7286                 gen_op_st_v(s, CODE64(s) + MO_32, cpu_T[0], cpu_A0);
7287             }
7288             break;
7289         case 2: /* lgdt */
7290         case 3: /* lidt */
7291             if (mod == 3) {
7292                 gen_update_cc_op(s);
7293                 gen_jmp_im(pc_start - s->cs_base);
7294                 switch(rm) {
7295                 case 0: /* VMRUN */
7296                     if (!(s->flags & HF_SVME_MASK) || !s->pe)
7297                         goto illegal_op;
7298                     if (s->cpl != 0) {
7299                         gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7300                         break;
7301                     } else {
7302                         gen_helper_vmrun(cpu_env, tcg_const_i32(s->aflag - 1),
7303                                          tcg_const_i32(s->pc - pc_start));
7304                         tcg_gen_exit_tb(0);
7305                         s->is_jmp = DISAS_TB_JUMP;
7306                     }
7307                     break;
7308                 case 1: /* VMMCALL */
7309                     if (!(s->flags & HF_SVME_MASK))
7310                         goto illegal_op;
7311                     gen_helper_vmmcall(cpu_env);
7312                     break;
7313                 case 2: /* VMLOAD */
7314                     if (!(s->flags & HF_SVME_MASK) || !s->pe)
7315                         goto illegal_op;
7316                     if (s->cpl != 0) {
7317                         gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7318                         break;
7319                     } else {
7320                         gen_helper_vmload(cpu_env, tcg_const_i32(s->aflag - 1));
7321                     }
7322                     break;
7323                 case 3: /* VMSAVE */
7324                     if (!(s->flags & HF_SVME_MASK) || !s->pe)
7325                         goto illegal_op;
7326                     if (s->cpl != 0) {
7327                         gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7328                         break;
7329                     } else {
7330                         gen_helper_vmsave(cpu_env, tcg_const_i32(s->aflag - 1));
7331                     }
7332                     break;
7333                 case 4: /* STGI */
7334                     if ((!(s->flags & HF_SVME_MASK) &&
7335                          !(s->cpuid_ext3_features & CPUID_EXT3_SKINIT)) ||
7336                         !s->pe)
7337                         goto illegal_op;
7338                     if (s->cpl != 0) {
7339                         gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7340                         break;
7341                     } else {
7342                         gen_helper_stgi(cpu_env);
7343                     }
7344                     break;
7345                 case 5: /* CLGI */
7346                     if (!(s->flags & HF_SVME_MASK) || !s->pe)
7347                         goto illegal_op;
7348                     if (s->cpl != 0) {
7349                         gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7350                         break;
7351                     } else {
7352                         gen_helper_clgi(cpu_env);
7353                     }
7354                     break;
7355                 case 6: /* SKINIT */
7356                     if ((!(s->flags & HF_SVME_MASK) &&
7357                          !(s->cpuid_ext3_features & CPUID_EXT3_SKINIT)) ||
7358                         !s->pe)
7359                         goto illegal_op;
7360                     gen_helper_skinit(cpu_env);
7361                     break;
7362                 case 7: /* INVLPGA */
7363                     if (!(s->flags & HF_SVME_MASK) || !s->pe)
7364                         goto illegal_op;
7365                     if (s->cpl != 0) {
7366                         gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7367                         break;
7368                     } else {
7369                         gen_helper_invlpga(cpu_env,
7370                                            tcg_const_i32(s->aflag - 1));
7371                     }
7372                     break;
7373                 default:
7374                     goto illegal_op;
7375                 }
7376             } else if (s->cpl != 0) {
7377                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7378             } else {
7379                 gen_svm_check_intercept(s, pc_start,
7380                                         op==2 ? SVM_EXIT_GDTR_WRITE : SVM_EXIT_IDTR_WRITE);
7381                 gen_lea_modrm(env, s, modrm);
7382                 gen_op_ld_v(s, MO_16, cpu_T[1], cpu_A0);
7383                 gen_add_A0_im(s, 2);
7384                 gen_op_ld_v(s, CODE64(s) + MO_32, cpu_T[0], cpu_A0);
7385                 if (dflag == MO_16) {
7386                     tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xffffff);
7387                 }
7388                 if (op == 2) {
7389                     tcg_gen_st_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,gdt.base));
7390                     tcg_gen_st32_tl(cpu_T[1], cpu_env, offsetof(CPUX86State,gdt.limit));
7391                 } else {
7392                     tcg_gen_st_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,idt.base));
7393                     tcg_gen_st32_tl(cpu_T[1], cpu_env, offsetof(CPUX86State,idt.limit));
7394                 }
7395             }
7396             break;
7397         case 4: /* smsw */
7398             gen_svm_check_intercept(s, pc_start, SVM_EXIT_READ_CR0);
7399 #if defined TARGET_X86_64 && defined HOST_WORDS_BIGENDIAN
7400             tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,cr[0]) + 4);
7401 #else
7402             tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,cr[0]));
7403 #endif
7404             gen_ldst_modrm(env, s, modrm, MO_16, OR_TMP0, 1);
7405             break;
7406         case 6: /* lmsw */
7407             if (s->cpl != 0) {
7408                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7409             } else {
7410                 gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_CR0);
7411                 gen_ldst_modrm(env, s, modrm, MO_16, OR_TMP0, 0);
7412                 gen_helper_lmsw(cpu_env, cpu_T[0]);
7413                 gen_jmp_im(s->pc - s->cs_base);
7414                 gen_eob(s);
7415             }
7416             break;
7417         case 7:
7418             if (mod != 3) { /* invlpg */
7419                 if (s->cpl != 0) {
7420                     gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7421                 } else {
7422                     gen_update_cc_op(s);
7423                     gen_jmp_im(pc_start - s->cs_base);
7424                     gen_lea_modrm(env, s, modrm);
7425                     gen_helper_invlpg(cpu_env, cpu_A0);
7426                     gen_jmp_im(s->pc - s->cs_base);
7427                     gen_eob(s);
7428                 }
7429             } else {
7430                 switch (rm) {
7431                 case 0: /* swapgs */
7432 #ifdef TARGET_X86_64
7433                     if (CODE64(s)) {
7434                         if (s->cpl != 0) {
7435                             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7436                         } else {
7437                             tcg_gen_ld_tl(cpu_T[0], cpu_env,
7438                                 offsetof(CPUX86State,segs[R_GS].base));
7439                             tcg_gen_ld_tl(cpu_T[1], cpu_env,
7440                                 offsetof(CPUX86State,kernelgsbase));
7441                             tcg_gen_st_tl(cpu_T[1], cpu_env,
7442                                 offsetof(CPUX86State,segs[R_GS].base));
7443                             tcg_gen_st_tl(cpu_T[0], cpu_env,
7444                                 offsetof(CPUX86State,kernelgsbase));
7445                         }
7446                     } else
7447 #endif
7448                     {
7449                         goto illegal_op;
7450                     }
7451                     break;
7452                 case 1: /* rdtscp */
7453                     if (!(s->cpuid_ext2_features & CPUID_EXT2_RDTSCP))
7454                         goto illegal_op;
7455                     gen_update_cc_op(s);
7456                     gen_jmp_im(pc_start - s->cs_base);
7457                     if (use_icount)
7458                         gen_io_start();
7459                     gen_helper_rdtscp(cpu_env);
7460                     if (use_icount) {
7461                         gen_io_end();
7462                         gen_jmp(s, s->pc - s->cs_base);
7463                     }
7464                     break;
7465                 default:
7466                     goto illegal_op;
7467                 }
7468             }
7469             break;
7470         default:
7471             goto illegal_op;
7472         }
7473         break;
7474     case 0x108: /* invd */
7475     case 0x109: /* wbinvd */
7476         if (s->cpl != 0) {
7477             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7478         } else {
7479             gen_svm_check_intercept(s, pc_start, (b & 2) ? SVM_EXIT_INVD : SVM_EXIT_WBINVD);
7480             /* nothing to do */
7481         }
7482         break;
7483     case 0x63: /* arpl or movslS (x86_64) */
7484 #ifdef TARGET_X86_64
7485         if (CODE64(s)) {
7486             int d_ot;
7487             /* d_ot is the size of destination */
7488             d_ot = dflag;
7489
7490             modrm = cpu_ldub_code(env, s->pc++);
7491             reg = ((modrm >> 3) & 7) | rex_r;
7492             mod = (modrm >> 6) & 3;
7493             rm = (modrm & 7) | REX_B(s);
7494
7495             if (mod == 3) {
7496                 gen_op_mov_v_reg(MO_32, cpu_T[0], rm);
7497                 /* sign extend */
7498                 if (d_ot == MO_64) {
7499                     tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
7500                 }
7501                 gen_op_mov_reg_v(d_ot, reg, cpu_T[0]);
7502             } else {
7503                 gen_lea_modrm(env, s, modrm);
7504                 gen_op_ld_v(s, MO_32 | MO_SIGN, cpu_T[0], cpu_A0);
7505                 gen_op_mov_reg_v(d_ot, reg, cpu_T[0]);
7506             }
7507         } else
7508 #endif
7509         {
7510             int label1;
7511             TCGv t0, t1, t2, a0;
7512
7513             if (!s->pe || s->vm86)
7514                 goto illegal_op;
7515             t0 = tcg_temp_local_new();
7516             t1 = tcg_temp_local_new();
7517             t2 = tcg_temp_local_new();
7518             ot = MO_16;
7519             modrm = cpu_ldub_code(env, s->pc++);
7520             reg = (modrm >> 3) & 7;
7521             mod = (modrm >> 6) & 3;
7522             rm = modrm & 7;
7523             if (mod != 3) {
7524                 gen_lea_modrm(env, s, modrm);
7525                 gen_op_ld_v(s, ot, t0, cpu_A0);
7526                 a0 = tcg_temp_local_new();
7527                 tcg_gen_mov_tl(a0, cpu_A0);
7528             } else {
7529                 gen_op_mov_v_reg(ot, t0, rm);
7530                 TCGV_UNUSED(a0);
7531             }
7532             gen_op_mov_v_reg(ot, t1, reg);
7533             tcg_gen_andi_tl(cpu_tmp0, t0, 3);
7534             tcg_gen_andi_tl(t1, t1, 3);
7535             tcg_gen_movi_tl(t2, 0);
7536             label1 = gen_new_label();
7537             tcg_gen_brcond_tl(TCG_COND_GE, cpu_tmp0, t1, label1);
7538             tcg_gen_andi_tl(t0, t0, ~3);
7539             tcg_gen_or_tl(t0, t0, t1);
7540             tcg_gen_movi_tl(t2, CC_Z);
7541             gen_set_label(label1);
7542             if (mod != 3) {
7543                 gen_op_st_v(s, ot, t0, a0);
7544                 tcg_temp_free(a0);
7545            } else {
7546                 gen_op_mov_reg_v(ot, rm, t0);
7547             }
7548             gen_compute_eflags(s);
7549             tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, ~CC_Z);
7550             tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, t2);
7551             tcg_temp_free(t0);
7552             tcg_temp_free(t1);
7553             tcg_temp_free(t2);
7554         }
7555         break;
7556     case 0x102: /* lar */
7557     case 0x103: /* lsl */
7558         {
7559             int label1;
7560             TCGv t0;
7561             if (!s->pe || s->vm86)
7562                 goto illegal_op;
7563             ot = dflag != MO_16 ? MO_32 : MO_16;
7564             modrm = cpu_ldub_code(env, s->pc++);
7565             reg = ((modrm >> 3) & 7) | rex_r;
7566             gen_ldst_modrm(env, s, modrm, MO_16, OR_TMP0, 0);
7567             t0 = tcg_temp_local_new();
7568             gen_update_cc_op(s);
7569             if (b == 0x102) {
7570                 gen_helper_lar(t0, cpu_env, cpu_T[0]);
7571             } else {
7572                 gen_helper_lsl(t0, cpu_env, cpu_T[0]);
7573             }
7574             tcg_gen_andi_tl(cpu_tmp0, cpu_cc_src, CC_Z);
7575             label1 = gen_new_label();
7576             tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, label1);
7577             gen_op_mov_reg_v(ot, reg, t0);
7578             gen_set_label(label1);
7579             set_cc_op(s, CC_OP_EFLAGS);
7580             tcg_temp_free(t0);
7581         }
7582         break;
7583     case 0x118:
7584         modrm = cpu_ldub_code(env, s->pc++);
7585         mod = (modrm >> 6) & 3;
7586         op = (modrm >> 3) & 7;
7587         switch(op) {
7588         case 0: /* prefetchnta */
7589         case 1: /* prefetchnt0 */
7590         case 2: /* prefetchnt0 */
7591         case 3: /* prefetchnt0 */
7592             if (mod == 3)
7593                 goto illegal_op;
7594             gen_lea_modrm(env, s, modrm);
7595             /* nothing more to do */
7596             break;
7597         default: /* nop (multi byte) */
7598             gen_nop_modrm(env, s, modrm);
7599             break;
7600         }
7601         break;
7602     case 0x119 ... 0x11f: /* nop (multi byte) */
7603         modrm = cpu_ldub_code(env, s->pc++);
7604         gen_nop_modrm(env, s, modrm);
7605         break;
7606     case 0x120: /* mov reg, crN */
7607     case 0x122: /* mov crN, reg */
7608         if (s->cpl != 0) {
7609             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7610         } else {
7611             modrm = cpu_ldub_code(env, s->pc++);
7612             /* Ignore the mod bits (assume (modrm&0xc0)==0xc0).
7613              * AMD documentation (24594.pdf) and testing of
7614              * intel 386 and 486 processors all show that the mod bits
7615              * are assumed to be 1's, regardless of actual values.
7616              */
7617             rm = (modrm & 7) | REX_B(s);
7618             reg = ((modrm >> 3) & 7) | rex_r;
7619             if (CODE64(s))
7620                 ot = MO_64;
7621             else
7622                 ot = MO_32;
7623             if ((prefixes & PREFIX_LOCK) && (reg == 0) &&
7624                 (s->cpuid_ext3_features & CPUID_EXT3_CR8LEG)) {
7625                 reg = 8;
7626             }
7627             switch(reg) {
7628             case 0:
7629             case 2:
7630             case 3:
7631             case 4:
7632             case 8:
7633                 gen_update_cc_op(s);
7634                 gen_jmp_im(pc_start - s->cs_base);
7635                 if (b & 2) {
7636                     gen_op_mov_v_reg(ot, cpu_T[0], rm);
7637                     gen_helper_write_crN(cpu_env, tcg_const_i32(reg),
7638                                          cpu_T[0]);
7639                     gen_jmp_im(s->pc - s->cs_base);
7640                     gen_eob(s);
7641                 } else {
7642                     gen_helper_read_crN(cpu_T[0], cpu_env, tcg_const_i32(reg));
7643                     gen_op_mov_reg_v(ot, rm, cpu_T[0]);
7644                 }
7645                 break;
7646             default:
7647                 goto illegal_op;
7648             }
7649         }
7650         break;
7651     case 0x121: /* mov reg, drN */
7652     case 0x123: /* mov drN, reg */
7653         if (s->cpl != 0) {
7654             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7655         } else {
7656             modrm = cpu_ldub_code(env, s->pc++);
7657             /* Ignore the mod bits (assume (modrm&0xc0)==0xc0).
7658              * AMD documentation (24594.pdf) and testing of
7659              * intel 386 and 486 processors all show that the mod bits
7660              * are assumed to be 1's, regardless of actual values.
7661              */
7662             rm = (modrm & 7) | REX_B(s);
7663             reg = ((modrm >> 3) & 7) | rex_r;
7664             if (CODE64(s))
7665                 ot = MO_64;
7666             else
7667                 ot = MO_32;
7668             /* XXX: do it dynamically with CR4.DE bit */
7669             if (reg == 4 || reg == 5 || reg >= 8)
7670                 goto illegal_op;
7671             if (b & 2) {
7672                 gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_DR0 + reg);
7673                 gen_op_mov_v_reg(ot, cpu_T[0], rm);
7674                 gen_helper_movl_drN_T0(cpu_env, tcg_const_i32(reg), cpu_T[0]);
7675                 gen_jmp_im(s->pc - s->cs_base);
7676                 gen_eob(s);
7677             } else {
7678                 gen_svm_check_intercept(s, pc_start, SVM_EXIT_READ_DR0 + reg);
7679                 tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,dr[reg]));
7680                 gen_op_mov_reg_v(ot, rm, cpu_T[0]);
7681             }
7682         }
7683         break;
7684     case 0x106: /* clts */
7685         if (s->cpl != 0) {
7686             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7687         } else {
7688             gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_CR0);
7689             gen_helper_clts(cpu_env);
7690             /* abort block because static cpu state changed */
7691             gen_jmp_im(s->pc - s->cs_base);
7692             gen_eob(s);
7693         }
7694         break;
7695     /* MMX/3DNow!/SSE/SSE2/SSE3/SSSE3/SSE4 support */
7696     case 0x1c3: /* MOVNTI reg, mem */
7697         if (!(s->cpuid_features & CPUID_SSE2))
7698             goto illegal_op;
7699         ot = mo_64_32(dflag);
7700         modrm = cpu_ldub_code(env, s->pc++);
7701         mod = (modrm >> 6) & 3;
7702         if (mod == 3)
7703             goto illegal_op;
7704         reg = ((modrm >> 3) & 7) | rex_r;
7705         /* generate a generic store */
7706         gen_ldst_modrm(env, s, modrm, ot, reg, 1);
7707         break;
7708     case 0x1ae:
7709         modrm = cpu_ldub_code(env, s->pc++);
7710         mod = (modrm >> 6) & 3;
7711         op = (modrm >> 3) & 7;
7712         switch(op) {
7713         case 0: /* fxsave */
7714             if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) ||
7715                 (s->prefix & PREFIX_LOCK))
7716                 goto illegal_op;
7717             if ((s->flags & HF_EM_MASK) || (s->flags & HF_TS_MASK)) {
7718                 gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
7719                 break;
7720             }
7721             gen_lea_modrm(env, s, modrm);
7722             gen_update_cc_op(s);
7723             gen_jmp_im(pc_start - s->cs_base);
7724             gen_helper_fxsave(cpu_env, cpu_A0, tcg_const_i32(dflag == MO_64));
7725             break;
7726         case 1: /* fxrstor */
7727             if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) ||
7728                 (s->prefix & PREFIX_LOCK))
7729                 goto illegal_op;
7730             if ((s->flags & HF_EM_MASK) || (s->flags & HF_TS_MASK)) {
7731                 gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
7732                 break;
7733             }
7734             gen_lea_modrm(env, s, modrm);
7735             gen_update_cc_op(s);
7736             gen_jmp_im(pc_start - s->cs_base);
7737             gen_helper_fxrstor(cpu_env, cpu_A0, tcg_const_i32(dflag == MO_64));
7738             break;
7739         case 2: /* ldmxcsr */
7740         case 3: /* stmxcsr */
7741             if (s->flags & HF_TS_MASK) {
7742                 gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
7743                 break;
7744             }
7745             if ((s->flags & HF_EM_MASK) || !(s->flags & HF_OSFXSR_MASK) ||
7746                 mod == 3)
7747                 goto illegal_op;
7748             gen_lea_modrm(env, s, modrm);
7749             if (op == 2) {
7750                 tcg_gen_qemu_ld_i32(cpu_tmp2_i32, cpu_A0,
7751                                     s->mem_index, MO_LEUL);
7752                 gen_helper_ldmxcsr(cpu_env, cpu_tmp2_i32);
7753             } else {
7754                 tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, mxcsr));
7755                 gen_op_st_v(s, MO_32, cpu_T[0], cpu_A0);
7756             }
7757             break;
7758         case 5: /* lfence */
7759         case 6: /* mfence */
7760             if ((modrm & 0xc7) != 0xc0 || !(s->cpuid_features & CPUID_SSE2))
7761                 goto illegal_op;
7762             break;
7763         case 7: /* sfence / clflush */
7764             if ((modrm & 0xc7) == 0xc0) {
7765                 /* sfence */
7766                 /* XXX: also check for cpuid_ext2_features & CPUID_EXT2_EMMX */
7767                 if (!(s->cpuid_features & CPUID_SSE))
7768                     goto illegal_op;
7769             } else {
7770                 /* clflush */
7771                 if (!(s->cpuid_features & CPUID_CLFLUSH))
7772                     goto illegal_op;
7773                 gen_lea_modrm(env, s, modrm);
7774             }
7775             break;
7776         default:
7777             goto illegal_op;
7778         }
7779         break;
7780     case 0x10d: /* 3DNow! prefetch(w) */
7781         modrm = cpu_ldub_code(env, s->pc++);
7782         mod = (modrm >> 6) & 3;
7783         if (mod == 3)
7784             goto illegal_op;
7785         gen_lea_modrm(env, s, modrm);
7786         /* ignore for now */
7787         break;
7788     case 0x1aa: /* rsm */
7789         gen_svm_check_intercept(s, pc_start, SVM_EXIT_RSM);
7790         if (!(s->flags & HF_SMM_MASK))
7791             goto illegal_op;
7792         gen_update_cc_op(s);
7793         gen_jmp_im(s->pc - s->cs_base);
7794         gen_helper_rsm(cpu_env);
7795         gen_eob(s);
7796         break;
7797     case 0x1b8: /* SSE4.2 popcnt */
7798         if ((prefixes & (PREFIX_REPZ | PREFIX_LOCK | PREFIX_REPNZ)) !=
7799              PREFIX_REPZ)
7800             goto illegal_op;
7801         if (!(s->cpuid_ext_features & CPUID_EXT_POPCNT))
7802             goto illegal_op;
7803
7804         modrm = cpu_ldub_code(env, s->pc++);
7805         reg = ((modrm >> 3) & 7) | rex_r;
7806
7807         if (s->prefix & PREFIX_DATA) {
7808             ot = MO_16;
7809         } else {
7810             ot = mo_64_32(dflag);
7811         }
7812
7813         gen_ldst_modrm(env, s, modrm, ot, OR_TMP0, 0);
7814         gen_helper_popcnt(cpu_T[0], cpu_env, cpu_T[0], tcg_const_i32(ot));
7815         gen_op_mov_reg_v(ot, reg, cpu_T[0]);
7816
7817         set_cc_op(s, CC_OP_EFLAGS);
7818         break;
7819     case 0x10e ... 0x10f:
7820         /* 3DNow! instructions, ignore prefixes */
7821         s->prefix &= ~(PREFIX_REPZ | PREFIX_REPNZ | PREFIX_DATA);
7822     case 0x110 ... 0x117:
7823     case 0x128 ... 0x12f:
7824     case 0x138 ... 0x13a:
7825     case 0x150 ... 0x179:
7826     case 0x17c ... 0x17f:
7827     case 0x1c2:
7828     case 0x1c4 ... 0x1c6:
7829     case 0x1d0 ... 0x1fe:
7830         gen_sse(env, s, b, pc_start, rex_r);
7831         break;
7832     default:
7833         goto illegal_op;
7834     }
7835     /* lock generation */
7836     if (s->prefix & PREFIX_LOCK)
7837         gen_helper_unlock();
7838     return s->pc;
7839  illegal_op:
7840     if (s->prefix & PREFIX_LOCK)
7841         gen_helper_unlock();
7842     /* XXX: ensure that no lock was generated */
7843     gen_exception(s, EXCP06_ILLOP, pc_start - s->cs_base);
7844     return s->pc;
7845 }
7846
7847 void optimize_flags_init(void)
7848 {
7849     static const char reg_names[CPU_NB_REGS][4] = {
7850 #ifdef TARGET_X86_64
7851         [R_EAX] = "rax",
7852         [R_EBX] = "rbx",
7853         [R_ECX] = "rcx",
7854         [R_EDX] = "rdx",
7855         [R_ESI] = "rsi",
7856         [R_EDI] = "rdi",
7857         [R_EBP] = "rbp",
7858         [R_ESP] = "rsp",
7859         [8]  = "r8",
7860         [9]  = "r9",
7861         [10] = "r10",
7862         [11] = "r11",
7863         [12] = "r12",
7864         [13] = "r13",
7865         [14] = "r14",
7866         [15] = "r15",
7867 #else
7868         [R_EAX] = "eax",
7869         [R_EBX] = "ebx",
7870         [R_ECX] = "ecx",
7871         [R_EDX] = "edx",
7872         [R_ESI] = "esi",
7873         [R_EDI] = "edi",
7874         [R_EBP] = "ebp",
7875         [R_ESP] = "esp",
7876 #endif
7877     };
7878     int i;
7879
7880     cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
7881     cpu_cc_op = tcg_global_mem_new_i32(TCG_AREG0,
7882                                        offsetof(CPUX86State, cc_op), "cc_op");
7883     cpu_cc_dst = tcg_global_mem_new(TCG_AREG0, offsetof(CPUX86State, cc_dst),
7884                                     "cc_dst");
7885     cpu_cc_src = tcg_global_mem_new(TCG_AREG0, offsetof(CPUX86State, cc_src),
7886                                     "cc_src");
7887     cpu_cc_src2 = tcg_global_mem_new(TCG_AREG0, offsetof(CPUX86State, cc_src2),
7888                                      "cc_src2");
7889
7890     for (i = 0; i < CPU_NB_REGS; ++i) {
7891         cpu_regs[i] = tcg_global_mem_new(TCG_AREG0,
7892                                          offsetof(CPUX86State, regs[i]),
7893                                          reg_names[i]);
7894     }
7895 }
7896
7897 /* generate intermediate code in gen_opc_buf and gen_opparam_buf for
7898    basic block 'tb'. If search_pc is TRUE, also generate PC
7899    information for each intermediate instruction. */
7900 static inline void gen_intermediate_code_internal(X86CPU *cpu,
7901                                                   TranslationBlock *tb,
7902                                                   bool search_pc)
7903 {
7904     CPUState *cs = CPU(cpu);
7905     CPUX86State *env = &cpu->env;
7906     DisasContext dc1, *dc = &dc1;
7907     target_ulong pc_ptr;
7908     uint16_t *gen_opc_end;
7909     CPUBreakpoint *bp;
7910     int j, lj;
7911     uint64_t flags;
7912     target_ulong pc_start;
7913     target_ulong cs_base;
7914     int num_insns;
7915     int max_insns;
7916
7917     /* generate intermediate code */
7918     pc_start = tb->pc;
7919     cs_base = tb->cs_base;
7920     flags = tb->flags;
7921
7922     dc->pe = (flags >> HF_PE_SHIFT) & 1;
7923     dc->code32 = (flags >> HF_CS32_SHIFT) & 1;
7924     dc->ss32 = (flags >> HF_SS32_SHIFT) & 1;
7925     dc->addseg = (flags >> HF_ADDSEG_SHIFT) & 1;
7926     dc->f_st = 0;
7927     dc->vm86 = (flags >> VM_SHIFT) & 1;
7928     dc->cpl = (flags >> HF_CPL_SHIFT) & 3;
7929     dc->iopl = (flags >> IOPL_SHIFT) & 3;
7930     dc->tf = (flags >> TF_SHIFT) & 1;
7931     dc->singlestep_enabled = cs->singlestep_enabled;
7932     dc->cc_op = CC_OP_DYNAMIC;
7933     dc->cc_op_dirty = false;
7934     dc->cs_base = cs_base;
7935     dc->tb = tb;
7936     dc->popl_esp_hack = 0;
7937     /* select memory access functions */
7938     dc->mem_index = 0;
7939     if (flags & HF_SOFTMMU_MASK) {
7940         dc->mem_index = cpu_mmu_index(env);
7941     }
7942     dc->cpuid_features = env->features[FEAT_1_EDX];
7943     dc->cpuid_ext_features = env->features[FEAT_1_ECX];
7944     dc->cpuid_ext2_features = env->features[FEAT_8000_0001_EDX];
7945     dc->cpuid_ext3_features = env->features[FEAT_8000_0001_ECX];
7946     dc->cpuid_7_0_ebx_features = env->features[FEAT_7_0_EBX];
7947 #ifdef TARGET_X86_64
7948     dc->lma = (flags >> HF_LMA_SHIFT) & 1;
7949     dc->code64 = (flags >> HF_CS64_SHIFT) & 1;
7950 #endif
7951     dc->flags = flags;
7952     dc->jmp_opt = !(dc->tf || cs->singlestep_enabled ||
7953                     (flags & HF_INHIBIT_IRQ_MASK)
7954 #ifndef CONFIG_SOFTMMU
7955                     || (flags & HF_SOFTMMU_MASK)
7956 #endif
7957                     );
7958 #if 0
7959     /* check addseg logic */
7960     if (!dc->addseg && (dc->vm86 || !dc->pe || !dc->code32))
7961         printf("ERROR addseg\n");
7962 #endif
7963
7964     cpu_T[0] = tcg_temp_new();
7965     cpu_T[1] = tcg_temp_new();
7966     cpu_A0 = tcg_temp_new();
7967
7968     cpu_tmp0 = tcg_temp_new();
7969     cpu_tmp1_i64 = tcg_temp_new_i64();
7970     cpu_tmp2_i32 = tcg_temp_new_i32();
7971     cpu_tmp3_i32 = tcg_temp_new_i32();
7972     cpu_tmp4 = tcg_temp_new();
7973     cpu_ptr0 = tcg_temp_new_ptr();
7974     cpu_ptr1 = tcg_temp_new_ptr();
7975     cpu_cc_srcT = tcg_temp_local_new();
7976
7977     gen_opc_end = tcg_ctx.gen_opc_buf + OPC_MAX_SIZE;
7978
7979     dc->is_jmp = DISAS_NEXT;
7980     pc_ptr = pc_start;
7981     lj = -1;
7982     num_insns = 0;
7983     max_insns = tb->cflags & CF_COUNT_MASK;
7984     if (max_insns == 0)
7985         max_insns = CF_COUNT_MASK;
7986
7987     gen_tb_start();
7988     for(;;) {
7989         if (unlikely(!QTAILQ_EMPTY(&cs->breakpoints))) {
7990             QTAILQ_FOREACH(bp, &cs->breakpoints, entry) {
7991                 if (bp->pc == pc_ptr &&
7992                     !((bp->flags & BP_CPU) && (tb->flags & HF_RF_MASK))) {
7993                     gen_debug(dc, pc_ptr - dc->cs_base);
7994                     break;
7995                 }
7996             }
7997         }
7998         if (search_pc) {
7999             j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
8000             if (lj < j) {
8001                 lj++;
8002                 while (lj < j)
8003                     tcg_ctx.gen_opc_instr_start[lj++] = 0;
8004             }
8005             tcg_ctx.gen_opc_pc[lj] = pc_ptr;
8006             gen_opc_cc_op[lj] = dc->cc_op;
8007             tcg_ctx.gen_opc_instr_start[lj] = 1;
8008             tcg_ctx.gen_opc_icount[lj] = num_insns;
8009         }
8010         if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO))
8011             gen_io_start();
8012
8013         pc_ptr = disas_insn(env, dc, pc_ptr);
8014         num_insns++;
8015         /* stop translation if indicated */
8016         if (dc->is_jmp)
8017             break;
8018         /* if single step mode, we generate only one instruction and
8019            generate an exception */
8020         /* if irq were inhibited with HF_INHIBIT_IRQ_MASK, we clear
8021            the flag and abort the translation to give the irqs a
8022            change to be happen */
8023         if (dc->tf || dc->singlestep_enabled ||
8024             (flags & HF_INHIBIT_IRQ_MASK)) {
8025             gen_jmp_im(pc_ptr - dc->cs_base);
8026             gen_eob(dc);
8027             break;
8028         }
8029         /* if too long translation, stop generation too */
8030         if (tcg_ctx.gen_opc_ptr >= gen_opc_end ||
8031             (pc_ptr - pc_start) >= (TARGET_PAGE_SIZE - 32) ||
8032             num_insns >= max_insns) {
8033             gen_jmp_im(pc_ptr - dc->cs_base);
8034             gen_eob(dc);
8035             break;
8036         }
8037         if (singlestep) {
8038             gen_jmp_im(pc_ptr - dc->cs_base);
8039             gen_eob(dc);
8040             break;
8041         }
8042     }
8043     if (tb->cflags & CF_LAST_IO)
8044         gen_io_end();
8045     gen_tb_end(tb, num_insns);
8046     *tcg_ctx.gen_opc_ptr = INDEX_op_end;
8047     /* we don't forget to fill the last values */
8048     if (search_pc) {
8049         j = tcg_ctx.gen_opc_ptr - tcg_ctx.gen_opc_buf;
8050         lj++;
8051         while (lj <= j)
8052             tcg_ctx.gen_opc_instr_start[lj++] = 0;
8053     }
8054
8055 #ifdef DEBUG_DISAS
8056     if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {
8057         int disas_flags;
8058         qemu_log("----------------\n");
8059         qemu_log("IN: %s\n", lookup_symbol(pc_start));
8060 #ifdef TARGET_X86_64
8061         if (dc->code64)
8062             disas_flags = 2;
8063         else
8064 #endif
8065             disas_flags = !dc->code32;
8066         log_target_disas(env, pc_start, pc_ptr - pc_start, disas_flags);
8067         qemu_log("\n");
8068     }
8069 #endif
8070
8071     if (!search_pc) {
8072         tb->size = pc_ptr - pc_start;
8073         tb->icount = num_insns;
8074     }
8075 }
8076
8077 void gen_intermediate_code(CPUX86State *env, TranslationBlock *tb)
8078 {
8079     gen_intermediate_code_internal(x86_env_get_cpu(env), tb, false);
8080 }
8081
8082 void gen_intermediate_code_pc(CPUX86State *env, TranslationBlock *tb)
8083 {
8084     gen_intermediate_code_internal(x86_env_get_cpu(env), tb, true);
8085 }
8086
8087 void restore_state_to_opc(CPUX86State *env, TranslationBlock *tb, int pc_pos)
8088 {
8089     int cc_op;
8090 #ifdef DEBUG_DISAS
8091     if (qemu_loglevel_mask(CPU_LOG_TB_OP)) {
8092         int i;
8093         qemu_log("RESTORE:\n");
8094         for(i = 0;i <= pc_pos; i++) {
8095             if (tcg_ctx.gen_opc_instr_start[i]) {
8096                 qemu_log("0x%04x: " TARGET_FMT_lx "\n", i,
8097                         tcg_ctx.gen_opc_pc[i]);
8098             }
8099         }
8100         qemu_log("pc_pos=0x%x eip=" TARGET_FMT_lx " cs_base=%x\n",
8101                 pc_pos, tcg_ctx.gen_opc_pc[pc_pos] - tb->cs_base,
8102                 (uint32_t)tb->cs_base);
8103     }
8104 #endif
8105     env->eip = tcg_ctx.gen_opc_pc[pc_pos] - tb->cs_base;
8106     cc_op = gen_opc_cc_op[pc_pos];
8107     if (cc_op != CC_OP_DYNAMIC)
8108         env->cc_op = cc_op;
8109 }