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