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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 #include <assert.h>
  27
  28 #include "cpu.h"
  29 #include "exec-all.h"
  30 #include "disas.h"
  31
  32 /* XXX: move that elsewhere */
  33 static uint16_t *gen_opc_ptr;
  34 static uint32_t *gen_opparam_ptr;
  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(x...) x
  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(x...)
  55 #define CODE64(s) 0
  56 #define REX_X(s) 0
  57 #define REX_B(s) 0
  58 #endif
  59
  60 #ifdef TARGET_X86_64
  61 static int x86_64_hregs;
  62 #endif
  63
  64 #ifdef USE_DIRECT_JUMP
  65 #define TBPARAM(x)
  66 #else
  67 #define TBPARAM(x) (long)(x)
  68 #endif
  69
  70 typedef struct DisasContext {
  71     /* current insn context */
  72     int override; /* -1 if no override */
  73     int prefix;
  74     int aflag, dflag;
  75     target_ulong pc; /* pc = eip + cs_base */
  76     int is_jmp; /* 1 = means jump (stop translation), 2 means CPU
  77                    static state change (stop translation) */
  78     /* current block context */
  79     target_ulong cs_base; /* base of CS segment */
  80     int pe;     /* protected mode */
  81     int code32; /* 32 bit code segment */
  82 #ifdef TARGET_X86_64
  83     int lma;    /* long mode active */
  84     int code64; /* 64 bit code segment */
  85     int rex_x, rex_b;
  86 #endif
  87     int ss32;   /* 32 bit stack segment */
  88     int cc_op;  /* current CC operation */
  89     int addseg; /* non zero if either DS/ES/SS have a non zero base */
  90     int f_st;   /* currently unused */
  91     int vm86;   /* vm86 mode */
  92     int cpl;
  93     int iopl;
  94     int tf;     /* TF cpu flag */
  95     int singlestep_enabled; /* "hardware" single step enabled */
  96     int jmp_opt; /* use direct block chaining for direct jumps */
  97     int mem_index; /* select memory access functions */
  98     uint64_t flags; /* all execution flags */
  99     struct TranslationBlock *tb;
 100     int popl_esp_hack; /* for correct popl with esp base handling */
 101     int rip_offset; /* only used in x86_64, but left for simplicity */
 102     int cpuid_features;
 103     int cpuid_ext_features;
 104 } DisasContext;
 105
 106 static void gen_eob(DisasContext *s);
 107 static void gen_jmp(DisasContext *s, target_ulong eip);
 108 static void gen_jmp_tb(DisasContext *s, target_ulong eip, int tb_num);
 109
 110 /* i386 arith/logic operations */
 111 enum {
 112     OP_ADDL,
 113     OP_ORL,
 114     OP_ADCL,
 115     OP_SBBL,
 116     OP_ANDL,
 117     OP_SUBL,
 118     OP_XORL,
 119     OP_CMPL,
 120 };
 121
 122 /* i386 shift ops */
 123 enum {
 124     OP_ROL,
 125     OP_ROR,
 126     OP_RCL,
 127     OP_RCR,
 128     OP_SHL,
 129     OP_SHR,
 130     OP_SHL1, /* undocumented */
 131     OP_SAR = 7,
 132 };
 133
 134 enum {
 135 #define DEF(s, n, copy_size) INDEX_op_ ## s,
 136 #include "opc.h"
 137 #undef DEF
 138     NB_OPS,
 139 };
 140
 141 #include "gen-op.h"
 142
 143 /* operand size */
 144 enum {
 145     OT_BYTE = 0,
 146     OT_WORD,
 147     OT_LONG,
 148     OT_QUAD,
 149 };
 150
 151 enum {
 152     /* I386 int registers */
 153     OR_EAX,   /* MUST be even numbered */
 154     OR_ECX,
 155     OR_EDX,
 156     OR_EBX,
 157     OR_ESP,
 158     OR_EBP,
 159     OR_ESI,
 160     OR_EDI,
 161
 162     OR_TMP0 = 16,    /* temporary operand register */
 163     OR_TMP1,
 164     OR_A0, /* temporary register used when doing address evaluation */
 165 };
 166
 167 #ifdef TARGET_X86_64
 168
 169 #define NB_OP_SIZES 4
 170
 171 #define DEF_REGS(prefix, suffix) \
 172   prefix ## EAX ## suffix,\
 173   prefix ## ECX ## suffix,\
 174   prefix ## EDX ## suffix,\
 175   prefix ## EBX ## suffix,\
 176   prefix ## ESP ## suffix,\
 177   prefix ## EBP ## suffix,\
 178   prefix ## ESI ## suffix,\
 179   prefix ## EDI ## suffix,\
 180   prefix ## R8 ## suffix,\
 181   prefix ## R9 ## suffix,\
 182   prefix ## R10 ## suffix,\
 183   prefix ## R11 ## suffix,\
 184   prefix ## R12 ## suffix,\
 185   prefix ## R13 ## suffix,\
 186   prefix ## R14 ## suffix,\
 187   prefix ## R15 ## suffix,
 188
 189 #define DEF_BREGS(prefixb, prefixh, suffix)             \
 190                                                         \
 191 static void prefixb ## ESP ## suffix ## _wrapper(void)  \
 192 {                                                       \
 193     if (x86_64_hregs)                                 \
 194         prefixb ## ESP ## suffix ();                    \
 195     else                                                \
 196         prefixh ## EAX ## suffix ();                    \
 197 }                                                       \
 198                                                         \
 199 static void prefixb ## EBP ## suffix ## _wrapper(void)  \
 200 {                                                       \
 201     if (x86_64_hregs)                                 \
 202         prefixb ## EBP ## suffix ();                    \
 203     else                                                \
 204         prefixh ## ECX ## suffix ();                    \
 205 }                                                       \
 206                                                         \
 207 static void prefixb ## ESI ## suffix ## _wrapper(void)  \
 208 {                                                       \
 209     if (x86_64_hregs)                                 \
 210         prefixb ## ESI ## suffix ();                    \
 211     else                                                \
 212         prefixh ## EDX ## suffix ();                    \
 213 }                                                       \
 214                                                         \
 215 static void prefixb ## EDI ## suffix ## _wrapper(void)  \
 216 {                                                       \
 217     if (x86_64_hregs)                                 \
 218         prefixb ## EDI ## suffix ();                    \
 219     else                                                \
 220         prefixh ## EBX ## suffix ();                    \
 221 }
 222
 223 DEF_BREGS(gen_op_movb_, gen_op_movh_, _T0)
 224 DEF_BREGS(gen_op_movb_, gen_op_movh_, _T1)
 225 DEF_BREGS(gen_op_movl_T0_, gen_op_movh_T0_, )
 226 DEF_BREGS(gen_op_movl_T1_, gen_op_movh_T1_, )
 227
 228 #else /* !TARGET_X86_64 */
 229
 230 #define NB_OP_SIZES 3
 231
 232 #define DEF_REGS(prefix, suffix) \
 233   prefix ## EAX ## suffix,\
 234   prefix ## ECX ## suffix,\
 235   prefix ## EDX ## suffix,\
 236   prefix ## EBX ## suffix,\
 237   prefix ## ESP ## suffix,\
 238   prefix ## EBP ## suffix,\
 239   prefix ## ESI ## suffix,\
 240   prefix ## EDI ## suffix,
 241
 242 #endif /* !TARGET_X86_64 */
 243
 244 static GenOpFunc *gen_op_mov_reg_T0[NB_OP_SIZES][CPU_NB_REGS] = {
 245     [OT_BYTE] = {
 246         gen_op_movb_EAX_T0,
 247         gen_op_movb_ECX_T0,
 248         gen_op_movb_EDX_T0,
 249         gen_op_movb_EBX_T0,
 250 #ifdef TARGET_X86_64
 251         gen_op_movb_ESP_T0_wrapper,
 252         gen_op_movb_EBP_T0_wrapper,
 253         gen_op_movb_ESI_T0_wrapper,
 254         gen_op_movb_EDI_T0_wrapper,
 255         gen_op_movb_R8_T0,
 256         gen_op_movb_R9_T0,
 257         gen_op_movb_R10_T0,
 258         gen_op_movb_R11_T0,
 259         gen_op_movb_R12_T0,
 260         gen_op_movb_R13_T0,
 261         gen_op_movb_R14_T0,
 262         gen_op_movb_R15_T0,
 263 #else
 264         gen_op_movh_EAX_T0,
 265         gen_op_movh_ECX_T0,
 266         gen_op_movh_EDX_T0,
 267         gen_op_movh_EBX_T0,
 268 #endif
 269     },
 270     [OT_WORD] = {
 271         DEF_REGS(gen_op_movw_, _T0)
 272     },
 273     [OT_LONG] = {
 274         DEF_REGS(gen_op_movl_, _T0)
 275     },
 276 #ifdef TARGET_X86_64
 277     [OT_QUAD] = {
 278         DEF_REGS(gen_op_movq_, _T0)
 279     },
 280 #endif
 281 };
 282
 283 static GenOpFunc *gen_op_mov_reg_T1[NB_OP_SIZES][CPU_NB_REGS] = {
 284     [OT_BYTE] = {
 285         gen_op_movb_EAX_T1,
 286         gen_op_movb_ECX_T1,
 287         gen_op_movb_EDX_T1,
 288         gen_op_movb_EBX_T1,
 289 #ifdef TARGET_X86_64
 290         gen_op_movb_ESP_T1_wrapper,
 291         gen_op_movb_EBP_T1_wrapper,
 292         gen_op_movb_ESI_T1_wrapper,
 293         gen_op_movb_EDI_T1_wrapper,
 294         gen_op_movb_R8_T1,
 295         gen_op_movb_R9_T1,
 296         gen_op_movb_R10_T1,
 297         gen_op_movb_R11_T1,
 298         gen_op_movb_R12_T1,
 299         gen_op_movb_R13_T1,
 300         gen_op_movb_R14_T1,
 301         gen_op_movb_R15_T1,
 302 #else
 303         gen_op_movh_EAX_T1,
 304         gen_op_movh_ECX_T1,
 305         gen_op_movh_EDX_T1,
 306         gen_op_movh_EBX_T1,
 307 #endif
 308     },
 309     [OT_WORD] = {
 310         DEF_REGS(gen_op_movw_, _T1)
 311     },
 312     [OT_LONG] = {
 313         DEF_REGS(gen_op_movl_, _T1)
 314     },
 315 #ifdef TARGET_X86_64
 316     [OT_QUAD] = {
 317         DEF_REGS(gen_op_movq_, _T1)
 318     },
 319 #endif
 320 };
 321
 322 static GenOpFunc *gen_op_mov_reg_A0[NB_OP_SIZES - 1][CPU_NB_REGS] = {
 323     [0] = {
 324         DEF_REGS(gen_op_movw_, _A0)
 325     },
 326     [1] = {
 327         DEF_REGS(gen_op_movl_, _A0)
 328     },
 329 #ifdef TARGET_X86_64
 330     [2] = {
 331         DEF_REGS(gen_op_movq_, _A0)
 332     },
 333 #endif
 334 };
 335
 336 static GenOpFunc *gen_op_mov_TN_reg[NB_OP_SIZES][2][CPU_NB_REGS] =
 337 {
 338     [OT_BYTE] = {
 339         {
 340             gen_op_movl_T0_EAX,
 341             gen_op_movl_T0_ECX,
 342             gen_op_movl_T0_EDX,
 343             gen_op_movl_T0_EBX,
 344 #ifdef TARGET_X86_64
 345             gen_op_movl_T0_ESP_wrapper,
 346             gen_op_movl_T0_EBP_wrapper,
 347             gen_op_movl_T0_ESI_wrapper,
 348             gen_op_movl_T0_EDI_wrapper,
 349             gen_op_movl_T0_R8,
 350             gen_op_movl_T0_R9,
 351             gen_op_movl_T0_R10,
 352             gen_op_movl_T0_R11,
 353             gen_op_movl_T0_R12,
 354             gen_op_movl_T0_R13,
 355             gen_op_movl_T0_R14,
 356             gen_op_movl_T0_R15,
 357 #else
 358             gen_op_movh_T0_EAX,
 359             gen_op_movh_T0_ECX,
 360             gen_op_movh_T0_EDX,
 361             gen_op_movh_T0_EBX,
 362 #endif
 363         },
 364         {
 365             gen_op_movl_T1_EAX,
 366             gen_op_movl_T1_ECX,
 367             gen_op_movl_T1_EDX,
 368             gen_op_movl_T1_EBX,
 369 #ifdef TARGET_X86_64
 370             gen_op_movl_T1_ESP_wrapper,
 371             gen_op_movl_T1_EBP_wrapper,
 372             gen_op_movl_T1_ESI_wrapper,
 373             gen_op_movl_T1_EDI_wrapper,
 374             gen_op_movl_T1_R8,
 375             gen_op_movl_T1_R9,
 376             gen_op_movl_T1_R10,
 377             gen_op_movl_T1_R11,
 378             gen_op_movl_T1_R12,
 379             gen_op_movl_T1_R13,
 380             gen_op_movl_T1_R14,
 381             gen_op_movl_T1_R15,
 382 #else
 383             gen_op_movh_T1_EAX,
 384             gen_op_movh_T1_ECX,
 385             gen_op_movh_T1_EDX,
 386             gen_op_movh_T1_EBX,
 387 #endif
 388         },
 389     },
 390     [OT_WORD] = {
 391         {
 392             DEF_REGS(gen_op_movl_T0_, )
 393         },
 394         {
 395             DEF_REGS(gen_op_movl_T1_, )
 396         },
 397     },
 398     [OT_LONG] = {
 399         {
 400             DEF_REGS(gen_op_movl_T0_, )
 401         },
 402         {
 403             DEF_REGS(gen_op_movl_T1_, )
 404         },
 405     },
 406 #ifdef TARGET_X86_64
 407     [OT_QUAD] = {
 408         {
 409             DEF_REGS(gen_op_movl_T0_, )
 410         },
 411         {
 412             DEF_REGS(gen_op_movl_T1_, )
 413         },
 414     },
 415 #endif
 416 };
 417
 418 static GenOpFunc *gen_op_movl_A0_reg[CPU_NB_REGS] = {
 419     DEF_REGS(gen_op_movl_A0_, )
 420 };
 421
 422 static GenOpFunc *gen_op_addl_A0_reg_sN[4][CPU_NB_REGS] = {
 423     [0] = {
 424         DEF_REGS(gen_op_addl_A0_, )
 425     },
 426     [1] = {
 427         DEF_REGS(gen_op_addl_A0_, _s1)
 428     },
 429     [2] = {
 430         DEF_REGS(gen_op_addl_A0_, _s2)
 431     },
 432     [3] = {
 433         DEF_REGS(gen_op_addl_A0_, _s3)
 434     },
 435 };
 436
 437 #ifdef TARGET_X86_64
 438 static GenOpFunc *gen_op_movq_A0_reg[CPU_NB_REGS] = {
 439     DEF_REGS(gen_op_movq_A0_, )
 440 };
 441
 442 static GenOpFunc *gen_op_addq_A0_reg_sN[4][CPU_NB_REGS] = {
 443     [0] = {
 444         DEF_REGS(gen_op_addq_A0_, )
 445     },
 446     [1] = {
 447         DEF_REGS(gen_op_addq_A0_, _s1)
 448     },
 449     [2] = {
 450         DEF_REGS(gen_op_addq_A0_, _s2)
 451     },
 452     [3] = {
 453         DEF_REGS(gen_op_addq_A0_, _s3)
 454     },
 455 };
 456 #endif
 457
 458 static GenOpFunc *gen_op_cmov_reg_T1_T0[NB_OP_SIZES - 1][CPU_NB_REGS] = {
 459     [0] = {
 460         DEF_REGS(gen_op_cmovw_, _T1_T0)
 461     },
 462     [1] = {
 463         DEF_REGS(gen_op_cmovl_, _T1_T0)
 464     },
 465 #ifdef TARGET_X86_64
 466     [2] = {
 467         DEF_REGS(gen_op_cmovq_, _T1_T0)
 468     },
 469 #endif
 470 };
 471
 472 static GenOpFunc *gen_op_arith_T0_T1_cc[8] = {
 473     NULL,
 474     gen_op_orl_T0_T1,
 475     NULL,
 476     NULL,
 477     gen_op_andl_T0_T1,
 478     NULL,
 479     gen_op_xorl_T0_T1,
 480     NULL,
 481 };
 482
 483 #define DEF_ARITHC(SUFFIX)\
 484     {\
 485         gen_op_adcb ## SUFFIX ## _T0_T1_cc,\
 486         gen_op_sbbb ## SUFFIX ## _T0_T1_cc,\
 487     },\
 488     {\
 489         gen_op_adcw ## SUFFIX ## _T0_T1_cc,\
 490         gen_op_sbbw ## SUFFIX ## _T0_T1_cc,\
 491     },\
 492     {\
 493         gen_op_adcl ## SUFFIX ## _T0_T1_cc,\
 494         gen_op_sbbl ## SUFFIX ## _T0_T1_cc,\
 495     },\
 496     {\
 497         X86_64_ONLY(gen_op_adcq ## SUFFIX ## _T0_T1_cc),\
 498         X86_64_ONLY(gen_op_sbbq ## SUFFIX ## _T0_T1_cc),\
 499     },
 500
 501 static GenOpFunc *gen_op_arithc_T0_T1_cc[4][2] = {
 502     DEF_ARITHC( )
 503 };
 504
 505 static GenOpFunc *gen_op_arithc_mem_T0_T1_cc[3 * 4][2] = {
 506     DEF_ARITHC(_raw)
 507 #ifndef CONFIG_USER_ONLY
 508     DEF_ARITHC(_kernel)
 509     DEF_ARITHC(_user)
 510 #endif
 511 };
 512
 513 static const int cc_op_arithb[8] = {
 514     CC_OP_ADDB,
 515     CC_OP_LOGICB,
 516     CC_OP_ADDB,
 517     CC_OP_SUBB,
 518     CC_OP_LOGICB,
 519     CC_OP_SUBB,
 520     CC_OP_LOGICB,
 521     CC_OP_SUBB,
 522 };
 523
 524 #define DEF_CMPXCHG(SUFFIX)\
 525     gen_op_cmpxchgb ## SUFFIX ## _T0_T1_EAX_cc,\
 526     gen_op_cmpxchgw ## SUFFIX ## _T0_T1_EAX_cc,\
 527     gen_op_cmpxchgl ## SUFFIX ## _T0_T1_EAX_cc,\
 528     X86_64_ONLY(gen_op_cmpxchgq ## SUFFIX ## _T0_T1_EAX_cc),
 529
 530 static GenOpFunc *gen_op_cmpxchg_T0_T1_EAX_cc[4] = {
 531     DEF_CMPXCHG( )
 532 };
 533
 534 static GenOpFunc *gen_op_cmpxchg_mem_T0_T1_EAX_cc[3 * 4] = {
 535     DEF_CMPXCHG(_raw)
 536 #ifndef CONFIG_USER_ONLY
 537     DEF_CMPXCHG(_kernel)
 538     DEF_CMPXCHG(_user)
 539 #endif
 540 };
 541
 542 #define DEF_SHIFT(SUFFIX)\
 543     {\
 544         gen_op_rolb ## SUFFIX ## _T0_T1_cc,\
 545         gen_op_rorb ## SUFFIX ## _T0_T1_cc,\
 546         gen_op_rclb ## SUFFIX ## _T0_T1_cc,\
 547         gen_op_rcrb ## SUFFIX ## _T0_T1_cc,\
 548         gen_op_shlb ## SUFFIX ## _T0_T1_cc,\
 549         gen_op_shrb ## SUFFIX ## _T0_T1_cc,\
 550         gen_op_shlb ## SUFFIX ## _T0_T1_cc,\
 551         gen_op_sarb ## SUFFIX ## _T0_T1_cc,\
 552     },\
 553     {\
 554         gen_op_rolw ## SUFFIX ## _T0_T1_cc,\
 555         gen_op_rorw ## SUFFIX ## _T0_T1_cc,\
 556         gen_op_rclw ## SUFFIX ## _T0_T1_cc,\
 557         gen_op_rcrw ## SUFFIX ## _T0_T1_cc,\
 558         gen_op_shlw ## SUFFIX ## _T0_T1_cc,\
 559         gen_op_shrw ## SUFFIX ## _T0_T1_cc,\
 560         gen_op_shlw ## SUFFIX ## _T0_T1_cc,\
 561         gen_op_sarw ## SUFFIX ## _T0_T1_cc,\
 562     },\
 563     {\
 564         gen_op_roll ## SUFFIX ## _T0_T1_cc,\
 565         gen_op_rorl ## SUFFIX ## _T0_T1_cc,\
 566         gen_op_rcll ## SUFFIX ## _T0_T1_cc,\
 567         gen_op_rcrl ## SUFFIX ## _T0_T1_cc,\
 568         gen_op_shll ## SUFFIX ## _T0_T1_cc,\
 569         gen_op_shrl ## SUFFIX ## _T0_T1_cc,\
 570         gen_op_shll ## SUFFIX ## _T0_T1_cc,\
 571         gen_op_sarl ## SUFFIX ## _T0_T1_cc,\
 572     },\
 573     {\
 574         X86_64_ONLY(gen_op_rolq ## SUFFIX ## _T0_T1_cc),\
 575         X86_64_ONLY(gen_op_rorq ## SUFFIX ## _T0_T1_cc),\
 576         X86_64_ONLY(gen_op_rclq ## SUFFIX ## _T0_T1_cc),\
 577         X86_64_ONLY(gen_op_rcrq ## SUFFIX ## _T0_T1_cc),\
 578         X86_64_ONLY(gen_op_shlq ## SUFFIX ## _T0_T1_cc),\
 579         X86_64_ONLY(gen_op_shrq ## SUFFIX ## _T0_T1_cc),\
 580         X86_64_ONLY(gen_op_shlq ## SUFFIX ## _T0_T1_cc),\
 581         X86_64_ONLY(gen_op_sarq ## SUFFIX ## _T0_T1_cc),\
 582     },
 583
 584 static GenOpFunc *gen_op_shift_T0_T1_cc[4][8] = {
 585     DEF_SHIFT( )
 586 };
 587
 588 static GenOpFunc *gen_op_shift_mem_T0_T1_cc[3 * 4][8] = {
 589     DEF_SHIFT(_raw)
 590 #ifndef CONFIG_USER_ONLY
 591     DEF_SHIFT(_kernel)
 592     DEF_SHIFT(_user)
 593 #endif
 594 };
 595
 596 #define DEF_SHIFTD(SUFFIX, op)\
 597     {\
 598         NULL,\
 599         NULL,\
 600     },\
 601     {\
 602         gen_op_shldw ## SUFFIX ## _T0_T1_ ## op ## _cc,\
 603         gen_op_shrdw ## SUFFIX ## _T0_T1_ ## op ## _cc,\
 604      },\
 605     {\
 606         gen_op_shldl ## SUFFIX ## _T0_T1_ ## op ## _cc,\
 607         gen_op_shrdl ## SUFFIX ## _T0_T1_ ## op ## _cc,\
 608     },\
 609     {\
 610 X86_64_DEF(gen_op_shldq ## SUFFIX ## _T0_T1_ ## op ## _cc,\
 611            gen_op_shrdq ## SUFFIX ## _T0_T1_ ## op ## _cc,)\
 612     },
 613
 614 static GenOpFunc1 *gen_op_shiftd_T0_T1_im_cc[4][2] = {
 615     DEF_SHIFTD(, im)
 616 };
 617
 618 static GenOpFunc *gen_op_shiftd_T0_T1_ECX_cc[4][2] = {
 619     DEF_SHIFTD(, ECX)
 620 };
 621
 622 static GenOpFunc1 *gen_op_shiftd_mem_T0_T1_im_cc[3 * 4][2] = {
 623     DEF_SHIFTD(_raw, im)
 624 #ifndef CONFIG_USER_ONLY
 625     DEF_SHIFTD(_kernel, im)
 626     DEF_SHIFTD(_user, im)
 627 #endif
 628 };
 629
 630 static GenOpFunc *gen_op_shiftd_mem_T0_T1_ECX_cc[3 * 4][2] = {
 631     DEF_SHIFTD(_raw, ECX)
 632 #ifndef CONFIG_USER_ONLY
 633     DEF_SHIFTD(_kernel, ECX)
 634     DEF_SHIFTD(_user, ECX)
 635 #endif
 636 };
 637
 638 static GenOpFunc *gen_op_btx_T0_T1_cc[3][4] = {
 639     [0] = {
 640         gen_op_btw_T0_T1_cc,
 641         gen_op_btsw_T0_T1_cc,
 642         gen_op_btrw_T0_T1_cc,
 643         gen_op_btcw_T0_T1_cc,
 644     },
 645     [1] = {
 646         gen_op_btl_T0_T1_cc,
 647         gen_op_btsl_T0_T1_cc,
 648         gen_op_btrl_T0_T1_cc,
 649         gen_op_btcl_T0_T1_cc,
 650     },
 651 #ifdef TARGET_X86_64
 652     [2] = {
 653         gen_op_btq_T0_T1_cc,
 654         gen_op_btsq_T0_T1_cc,
 655         gen_op_btrq_T0_T1_cc,
 656         gen_op_btcq_T0_T1_cc,
 657     },
 658 #endif
 659 };
 660
 661 static GenOpFunc *gen_op_add_bit_A0_T1[3] = {
 662     gen_op_add_bitw_A0_T1,
 663     gen_op_add_bitl_A0_T1,
 664     X86_64_ONLY(gen_op_add_bitq_A0_T1),
 665 };
 666
 667 static GenOpFunc *gen_op_bsx_T0_cc[3][2] = {
 668     [0] = {
 669         gen_op_bsfw_T0_cc,
 670         gen_op_bsrw_T0_cc,
 671     },
 672     [1] = {
 673         gen_op_bsfl_T0_cc,
 674         gen_op_bsrl_T0_cc,
 675     },
 676 #ifdef TARGET_X86_64
 677     [2] = {
 678         gen_op_bsfq_T0_cc,
 679         gen_op_bsrq_T0_cc,
 680     },
 681 #endif
 682 };
 683
 684 static GenOpFunc *gen_op_lds_T0_A0[3 * 4] = {
 685     gen_op_ldsb_raw_T0_A0,
 686     gen_op_ldsw_raw_T0_A0,
 687     X86_64_ONLY(gen_op_ldsl_raw_T0_A0),
 688     NULL,
 689 #ifndef CONFIG_USER_ONLY
 690     gen_op_ldsb_kernel_T0_A0,
 691     gen_op_ldsw_kernel_T0_A0,
 692     X86_64_ONLY(gen_op_ldsl_kernel_T0_A0),
 693     NULL,
 694
 695     gen_op_ldsb_user_T0_A0,
 696     gen_op_ldsw_user_T0_A0,
 697     X86_64_ONLY(gen_op_ldsl_user_T0_A0),
 698     NULL,
 699 #endif
 700 };
 701
 702 static GenOpFunc *gen_op_ldu_T0_A0[3 * 4] = {
 703     gen_op_ldub_raw_T0_A0,
 704     gen_op_lduw_raw_T0_A0,
 705     NULL,
 706     NULL,
 707
 708 #ifndef CONFIG_USER_ONLY
 709     gen_op_ldub_kernel_T0_A0,
 710     gen_op_lduw_kernel_T0_A0,
 711     NULL,
 712     NULL,
 713
 714     gen_op_ldub_user_T0_A0,
 715     gen_op_lduw_user_T0_A0,
 716     NULL,
 717     NULL,
 718 #endif
 719 };
 720
 721 /* sign does not matter, except for lidt/lgdt call (TODO: fix it) */
 722 static GenOpFunc *gen_op_ld_T0_A0[3 * 4] = {
 723     gen_op_ldub_raw_T0_A0,
 724     gen_op_lduw_raw_T0_A0,
 725     gen_op_ldl_raw_T0_A0,
 726     X86_64_ONLY(gen_op_ldq_raw_T0_A0),
 727
 728 #ifndef CONFIG_USER_ONLY
 729     gen_op_ldub_kernel_T0_A0,
 730     gen_op_lduw_kernel_T0_A0,
 731     gen_op_ldl_kernel_T0_A0,
 732     X86_64_ONLY(gen_op_ldq_kernel_T0_A0),
 733
 734     gen_op_ldub_user_T0_A0,
 735     gen_op_lduw_user_T0_A0,
 736     gen_op_ldl_user_T0_A0,
 737     X86_64_ONLY(gen_op_ldq_user_T0_A0),
 738 #endif
 739 };
 740
 741 static GenOpFunc *gen_op_ld_T1_A0[3 * 4] = {
 742     gen_op_ldub_raw_T1_A0,
 743     gen_op_lduw_raw_T1_A0,
 744     gen_op_ldl_raw_T1_A0,
 745     X86_64_ONLY(gen_op_ldq_raw_T1_A0),
 746
 747 #ifndef CONFIG_USER_ONLY
 748     gen_op_ldub_kernel_T1_A0,
 749     gen_op_lduw_kernel_T1_A0,
 750     gen_op_ldl_kernel_T1_A0,
 751     X86_64_ONLY(gen_op_ldq_kernel_T1_A0),
 752
 753     gen_op_ldub_user_T1_A0,
 754     gen_op_lduw_user_T1_A0,
 755     gen_op_ldl_user_T1_A0,
 756     X86_64_ONLY(gen_op_ldq_user_T1_A0),
 757 #endif
 758 };
 759
 760 static GenOpFunc *gen_op_st_T0_A0[3 * 4] = {
 761     gen_op_stb_raw_T0_A0,
 762     gen_op_stw_raw_T0_A0,
 763     gen_op_stl_raw_T0_A0,
 764     X86_64_ONLY(gen_op_stq_raw_T0_A0),
 765
 766 #ifndef CONFIG_USER_ONLY
 767     gen_op_stb_kernel_T0_A0,
 768     gen_op_stw_kernel_T0_A0,
 769     gen_op_stl_kernel_T0_A0,
 770     X86_64_ONLY(gen_op_stq_kernel_T0_A0),
 771
 772     gen_op_stb_user_T0_A0,
 773     gen_op_stw_user_T0_A0,
 774     gen_op_stl_user_T0_A0,
 775     X86_64_ONLY(gen_op_stq_user_T0_A0),
 776 #endif
 777 };
 778
 779 static GenOpFunc *gen_op_st_T1_A0[3 * 4] = {
 780     NULL,
 781     gen_op_stw_raw_T1_A0,
 782     gen_op_stl_raw_T1_A0,
 783     X86_64_ONLY(gen_op_stq_raw_T1_A0),
 784
 785 #ifndef CONFIG_USER_ONLY
 786     NULL,
 787     gen_op_stw_kernel_T1_A0,
 788     gen_op_stl_kernel_T1_A0,
 789     X86_64_ONLY(gen_op_stq_kernel_T1_A0),
 790
 791     NULL,
 792     gen_op_stw_user_T1_A0,
 793     gen_op_stl_user_T1_A0,
 794     X86_64_ONLY(gen_op_stq_user_T1_A0),
 795 #endif
 796 };
 797
 798 static inline void gen_jmp_im(target_ulong pc)
 799 {
 800 #ifdef TARGET_X86_64
 801     if (pc == (uint32_t)pc) {
 802         gen_op_movl_eip_im(pc);
 803     } else if (pc == (int32_t)pc) {
 804         gen_op_movq_eip_im(pc);
 805     } else {
 806         gen_op_movq_eip_im64(pc >> 32, pc);
 807     }
 808 #else
 809     gen_op_movl_eip_im(pc);
 810 #endif
 811 }
 812
 813 static inline void gen_string_movl_A0_ESI(DisasContext *s)
 814 {
 815     int override;
 816
 817     override = s->override;
 818 #ifdef TARGET_X86_64
 819     if (s->aflag == 2) {
 820         if (override >= 0) {
 821             gen_op_movq_A0_seg(offsetof(CPUX86State,segs[override].base));
 822             gen_op_addq_A0_reg_sN[0][R_ESI]();
 823         } else {
 824             gen_op_movq_A0_reg[R_ESI]();
 825         }
 826     } else
 827 #endif
 828     if (s->aflag) {
 829         /* 32 bit address */
 830         if (s->addseg && override < 0)
 831             override = R_DS;
 832         if (override >= 0) {
 833             gen_op_movl_A0_seg(offsetof(CPUX86State,segs[override].base));
 834             gen_op_addl_A0_reg_sN[0][R_ESI]();
 835         } else {
 836             gen_op_movl_A0_reg[R_ESI]();
 837         }
 838     } else {
 839         /* 16 address, always override */
 840         if (override < 0)
 841             override = R_DS;
 842         gen_op_movl_A0_reg[R_ESI]();
 843         gen_op_andl_A0_ffff();
 844         gen_op_addl_A0_seg(offsetof(CPUX86State,segs[override].base));
 845     }
 846 }
 847
 848 static inline void gen_string_movl_A0_EDI(DisasContext *s)
 849 {
 850 #ifdef TARGET_X86_64
 851     if (s->aflag == 2) {
 852         gen_op_movq_A0_reg[R_EDI]();
 853     } else
 854 #endif
 855     if (s->aflag) {
 856         if (s->addseg) {
 857             gen_op_movl_A0_seg(offsetof(CPUX86State,segs[R_ES].base));
 858             gen_op_addl_A0_reg_sN[0][R_EDI]();
 859         } else {
 860             gen_op_movl_A0_reg[R_EDI]();
 861         }
 862     } else {
 863         gen_op_movl_A0_reg[R_EDI]();
 864         gen_op_andl_A0_ffff();
 865         gen_op_addl_A0_seg(offsetof(CPUX86State,segs[R_ES].base));
 866     }
 867 }
 868
 869 static GenOpFunc *gen_op_movl_T0_Dshift[4] = {
 870     gen_op_movl_T0_Dshiftb,
 871     gen_op_movl_T0_Dshiftw,
 872     gen_op_movl_T0_Dshiftl,
 873     X86_64_ONLY(gen_op_movl_T0_Dshiftq),
 874 };
 875
 876 static GenOpFunc1 *gen_op_jnz_ecx[3] = {
 877     gen_op_jnz_ecxw,
 878     gen_op_jnz_ecxl,
 879     X86_64_ONLY(gen_op_jnz_ecxq),
 880 };
 881
 882 static GenOpFunc1 *gen_op_jz_ecx[3] = {
 883     gen_op_jz_ecxw,
 884     gen_op_jz_ecxl,
 885     X86_64_ONLY(gen_op_jz_ecxq),
 886 };
 887
 888 static GenOpFunc *gen_op_dec_ECX[3] = {
 889     gen_op_decw_ECX,
 890     gen_op_decl_ECX,
 891     X86_64_ONLY(gen_op_decq_ECX),
 892 };
 893
 894 static GenOpFunc1 *gen_op_string_jnz_sub[2][4] = {
 895     {
 896         gen_op_jnz_subb,
 897         gen_op_jnz_subw,
 898         gen_op_jnz_subl,
 899         X86_64_ONLY(gen_op_jnz_subq),
 900     },
 901     {
 902         gen_op_jz_subb,
 903         gen_op_jz_subw,
 904         gen_op_jz_subl,
 905         X86_64_ONLY(gen_op_jz_subq),
 906     },
 907 };
 908
 909 static GenOpFunc *gen_op_in_DX_T0[3] = {
 910     gen_op_inb_DX_T0,
 911     gen_op_inw_DX_T0,
 912     gen_op_inl_DX_T0,
 913 };
 914
 915 static GenOpFunc *gen_op_out_DX_T0[3] = {
 916     gen_op_outb_DX_T0,
 917     gen_op_outw_DX_T0,
 918     gen_op_outl_DX_T0,
 919 };
 920
 921 static GenOpFunc *gen_op_in[3] = {
 922     gen_op_inb_T0_T1,
 923     gen_op_inw_T0_T1,
 924     gen_op_inl_T0_T1,
 925 };
 926
 927 static GenOpFunc *gen_op_out[3] = {
 928     gen_op_outb_T0_T1,
 929     gen_op_outw_T0_T1,
 930     gen_op_outl_T0_T1,
 931 };
 932
 933 static GenOpFunc *gen_check_io_T0[3] = {
 934     gen_op_check_iob_T0,
 935     gen_op_check_iow_T0,
 936     gen_op_check_iol_T0,
 937 };
 938
 939 static GenOpFunc *gen_check_io_DX[3] = {
 940     gen_op_check_iob_DX,
 941     gen_op_check_iow_DX,
 942     gen_op_check_iol_DX,
 943 };
 944
 945 static void gen_check_io(DisasContext *s, int ot, int use_dx, target_ulong cur_eip)
 946 {
 947     if (s->pe && (s->cpl > s->iopl || s->vm86)) {
 948         if (s->cc_op != CC_OP_DYNAMIC)
 949             gen_op_set_cc_op(s->cc_op);
 950         gen_jmp_im(cur_eip);
 951         if (use_dx)
 952             gen_check_io_DX[ot]();
 953         else
 954             gen_check_io_T0[ot]();
 955     }
 956 }
 957
 958 static inline void gen_movs(DisasContext *s, int ot)
 959 {
 960     gen_string_movl_A0_ESI(s);
 961     gen_op_ld_T0_A0[ot + s->mem_index]();
 962     gen_string_movl_A0_EDI(s);
 963     gen_op_st_T0_A0[ot + s->mem_index]();
 964     gen_op_movl_T0_Dshift[ot]();
 965 #ifdef TARGET_X86_64
 966     if (s->aflag == 2) {
 967         gen_op_addq_ESI_T0();
 968         gen_op_addq_EDI_T0();
 969     } else
 970 #endif
 971     if (s->aflag) {
 972         gen_op_addl_ESI_T0();
 973         gen_op_addl_EDI_T0();
 974     } else {
 975         gen_op_addw_ESI_T0();
 976         gen_op_addw_EDI_T0();
 977     }
 978 }
 979
 980 static inline void gen_update_cc_op(DisasContext *s)
 981 {
 982     if (s->cc_op != CC_OP_DYNAMIC) {
 983         gen_op_set_cc_op(s->cc_op);
 984         s->cc_op = CC_OP_DYNAMIC;
 985     }
 986 }
 987
 988 /* XXX: does not work with gdbstub "ice" single step - not a
 989    serious problem */
 990 static int gen_jz_ecx_string(DisasContext *s, target_ulong next_eip)
 991 {
 992     int l1, l2;
 993
 994     l1 = gen_new_label();
 995     l2 = gen_new_label();
 996     gen_op_jnz_ecx[s->aflag](l1);
 997     gen_set_label(l2);
 998     gen_jmp_tb(s, next_eip, 1);
 999     gen_set_label(l1);
1000     return l2;
1001 }
1002
1003 static inline void gen_stos(DisasContext *s, int ot)
1004 {
1005     gen_op_mov_TN_reg[OT_LONG][0][R_EAX]();
1006     gen_string_movl_A0_EDI(s);
1007     gen_op_st_T0_A0[ot + s->mem_index]();
1008     gen_op_movl_T0_Dshift[ot]();
1009 #ifdef TARGET_X86_64
1010     if (s->aflag == 2) {
1011         gen_op_addq_EDI_T0();
1012     } else
1013 #endif
1014     if (s->aflag) {
1015         gen_op_addl_EDI_T0();
1016     } else {
1017         gen_op_addw_EDI_T0();
1018     }
1019 }
1020
1021 static inline void gen_lods(DisasContext *s, int ot)
1022 {
1023     gen_string_movl_A0_ESI(s);
1024     gen_op_ld_T0_A0[ot + s->mem_index]();
1025     gen_op_mov_reg_T0[ot][R_EAX]();
1026     gen_op_movl_T0_Dshift[ot]();
1027 #ifdef TARGET_X86_64
1028     if (s->aflag == 2) {
1029         gen_op_addq_ESI_T0();
1030     } else
1031 #endif
1032     if (s->aflag) {
1033         gen_op_addl_ESI_T0();
1034     } else {
1035         gen_op_addw_ESI_T0();
1036     }
1037 }
1038
1039 static inline void gen_scas(DisasContext *s, int ot)
1040 {
1041     gen_op_mov_TN_reg[OT_LONG][0][R_EAX]();
1042     gen_string_movl_A0_EDI(s);
1043     gen_op_ld_T1_A0[ot + s->mem_index]();
1044     gen_op_cmpl_T0_T1_cc();
1045     gen_op_movl_T0_Dshift[ot]();
1046 #ifdef TARGET_X86_64
1047     if (s->aflag == 2) {
1048         gen_op_addq_EDI_T0();
1049     } else
1050 #endif
1051     if (s->aflag) {
1052         gen_op_addl_EDI_T0();
1053     } else {
1054         gen_op_addw_EDI_T0();
1055     }
1056 }
1057
1058 static inline void gen_cmps(DisasContext *s, int ot)
1059 {
1060     gen_string_movl_A0_ESI(s);
1061     gen_op_ld_T0_A0[ot + s->mem_index]();
1062     gen_string_movl_A0_EDI(s);
1063     gen_op_ld_T1_A0[ot + s->mem_index]();
1064     gen_op_cmpl_T0_T1_cc();
1065     gen_op_movl_T0_Dshift[ot]();
1066 #ifdef TARGET_X86_64
1067     if (s->aflag == 2) {
1068         gen_op_addq_ESI_T0();
1069         gen_op_addq_EDI_T0();
1070     } else
1071 #endif
1072     if (s->aflag) {
1073         gen_op_addl_ESI_T0();
1074         gen_op_addl_EDI_T0();
1075     } else {
1076         gen_op_addw_ESI_T0();
1077         gen_op_addw_EDI_T0();
1078     }
1079 }
1080
1081 static inline void gen_ins(DisasContext *s, int ot)
1082 {
1083     gen_string_movl_A0_EDI(s);
1084     gen_op_movl_T0_0();
1085     gen_op_st_T0_A0[ot + s->mem_index]();
1086     gen_op_in_DX_T0[ot]();
1087     gen_op_st_T0_A0[ot + s->mem_index]();
1088     gen_op_movl_T0_Dshift[ot]();
1089 #ifdef TARGET_X86_64
1090     if (s->aflag == 2) {
1091         gen_op_addq_EDI_T0();
1092     } else
1093 #endif
1094     if (s->aflag) {
1095         gen_op_addl_EDI_T0();
1096     } else {
1097         gen_op_addw_EDI_T0();
1098     }
1099 }
1100
1101 static inline void gen_outs(DisasContext *s, int ot)
1102 {
1103     gen_string_movl_A0_ESI(s);
1104     gen_op_ld_T0_A0[ot + s->mem_index]();
1105     gen_op_out_DX_T0[ot]();
1106     gen_op_movl_T0_Dshift[ot]();
1107 #ifdef TARGET_X86_64
1108     if (s->aflag == 2) {
1109         gen_op_addq_ESI_T0();
1110     } else
1111 #endif
1112     if (s->aflag) {
1113         gen_op_addl_ESI_T0();
1114     } else {
1115         gen_op_addw_ESI_T0();
1116     }
1117 }
1118
1119 /* same method as Valgrind : we generate jumps to current or next
1120    instruction */
1121 #define GEN_REPZ(op)                                                          \
1122 static inline void gen_repz_ ## op(DisasContext *s, int ot,                   \
1123                                  target_ulong cur_eip, target_ulong next_eip) \
1124 {                                                                             \
1125     int l2;\
1126     gen_update_cc_op(s);                                                      \
1127     l2 = gen_jz_ecx_string(s, next_eip);                                      \
1128     gen_ ## op(s, ot);                                                        \
1129     gen_op_dec_ECX[s->aflag]();                                               \
1130     /* a loop would cause two single step exceptions if ECX = 1               \
1131        before rep string_insn */                                              \
1132     if (!s->jmp_opt)                                                          \
1133         gen_op_jz_ecx[s->aflag](l2);                                          \
1134     gen_jmp(s, cur_eip);                                                      \
1135 }
1136
1137 #define GEN_REPZ2(op)                                                         \
1138 static inline void gen_repz_ ## op(DisasContext *s, int ot,                   \
1139                                    target_ulong cur_eip,                      \
1140                                    target_ulong next_eip,                     \
1141                                    int nz)                                    \
1142 {                                                                             \
1143     int l2;\
1144     gen_update_cc_op(s);                                                      \
1145     l2 = gen_jz_ecx_string(s, next_eip);                                      \
1146     gen_ ## op(s, ot);                                                        \
1147     gen_op_dec_ECX[s->aflag]();                                               \
1148     gen_op_set_cc_op(CC_OP_SUBB + ot);                                        \
1149     gen_op_string_jnz_sub[nz][ot](l2);\
1150     if (!s->jmp_opt)                                                          \
1151         gen_op_jz_ecx[s->aflag](l2);                                          \
1152     gen_jmp(s, cur_eip);                                                      \
1153 }
1154
1155 GEN_REPZ(movs)
1156 GEN_REPZ(stos)
1157 GEN_REPZ(lods)
1158 GEN_REPZ(ins)
1159 GEN_REPZ(outs)
1160 GEN_REPZ2(scas)
1161 GEN_REPZ2(cmps)
1162
1163 enum {
1164     JCC_O,
1165     JCC_B,
1166     JCC_Z,
1167     JCC_BE,
1168     JCC_S,
1169     JCC_P,
1170     JCC_L,
1171     JCC_LE,
1172 };
1173
1174 static GenOpFunc1 *gen_jcc_sub[4][8] = {
1175     [OT_BYTE] = {
1176         NULL,
1177         gen_op_jb_subb,
1178         gen_op_jz_subb,
1179         gen_op_jbe_subb,
1180         gen_op_js_subb,
1181         NULL,
1182         gen_op_jl_subb,
1183         gen_op_jle_subb,
1184     },
1185     [OT_WORD] = {
1186         NULL,
1187         gen_op_jb_subw,
1188         gen_op_jz_subw,
1189         gen_op_jbe_subw,
1190         gen_op_js_subw,
1191         NULL,
1192         gen_op_jl_subw,
1193         gen_op_jle_subw,
1194     },
1195     [OT_LONG] = {
1196         NULL,
1197         gen_op_jb_subl,
1198         gen_op_jz_subl,
1199         gen_op_jbe_subl,
1200         gen_op_js_subl,
1201         NULL,
1202         gen_op_jl_subl,
1203         gen_op_jle_subl,
1204     },
1205 #ifdef TARGET_X86_64
1206     [OT_QUAD] = {
1207         NULL,
1208         BUGGY_64(gen_op_jb_subq),
1209         gen_op_jz_subq,
1210         BUGGY_64(gen_op_jbe_subq),
1211         gen_op_js_subq,
1212         NULL,
1213         BUGGY_64(gen_op_jl_subq),
1214         BUGGY_64(gen_op_jle_subq),
1215     },
1216 #endif
1217 };
1218 static GenOpFunc1 *gen_op_loop[3][4] = {
1219     [0] = {
1220         gen_op_loopnzw,
1221         gen_op_loopzw,
1222         gen_op_jnz_ecxw,
1223     },
1224     [1] = {
1225         gen_op_loopnzl,
1226         gen_op_loopzl,
1227         gen_op_jnz_ecxl,
1228     },
1229 #ifdef TARGET_X86_64
1230     [2] = {
1231         gen_op_loopnzq,
1232         gen_op_loopzq,
1233         gen_op_jnz_ecxq,
1234     },
1235 #endif
1236 };
1237
1238 static GenOpFunc *gen_setcc_slow[8] = {
1239     gen_op_seto_T0_cc,
1240     gen_op_setb_T0_cc,
1241     gen_op_setz_T0_cc,
1242     gen_op_setbe_T0_cc,
1243     gen_op_sets_T0_cc,
1244     gen_op_setp_T0_cc,
1245     gen_op_setl_T0_cc,
1246     gen_op_setle_T0_cc,
1247 };
1248
1249 static GenOpFunc *gen_setcc_sub[4][8] = {
1250     [OT_BYTE] = {
1251         NULL,
1252         gen_op_setb_T0_subb,
1253         gen_op_setz_T0_subb,
1254         gen_op_setbe_T0_subb,
1255         gen_op_sets_T0_subb,
1256         NULL,
1257         gen_op_setl_T0_subb,
1258         gen_op_setle_T0_subb,
1259     },
1260     [OT_WORD] = {
1261         NULL,
1262         gen_op_setb_T0_subw,
1263         gen_op_setz_T0_subw,
1264         gen_op_setbe_T0_subw,
1265         gen_op_sets_T0_subw,
1266         NULL,
1267         gen_op_setl_T0_subw,
1268         gen_op_setle_T0_subw,
1269     },
1270     [OT_LONG] = {
1271         NULL,
1272         gen_op_setb_T0_subl,
1273         gen_op_setz_T0_subl,
1274         gen_op_setbe_T0_subl,
1275         gen_op_sets_T0_subl,
1276         NULL,
1277         gen_op_setl_T0_subl,
1278         gen_op_setle_T0_subl,
1279     },
1280 #ifdef TARGET_X86_64
1281     [OT_QUAD] = {
1282         NULL,
1283         gen_op_setb_T0_subq,
1284         gen_op_setz_T0_subq,
1285         gen_op_setbe_T0_subq,
1286         gen_op_sets_T0_subq,
1287         NULL,
1288         gen_op_setl_T0_subq,
1289         gen_op_setle_T0_subq,
1290     },
1291 #endif
1292 };
1293
1294 static GenOpFunc *gen_op_fp_arith_ST0_FT0[8] = {
1295     gen_op_fadd_ST0_FT0,
1296     gen_op_fmul_ST0_FT0,
1297     gen_op_fcom_ST0_FT0,
1298     gen_op_fcom_ST0_FT0,
1299     gen_op_fsub_ST0_FT0,
1300     gen_op_fsubr_ST0_FT0,
1301     gen_op_fdiv_ST0_FT0,
1302     gen_op_fdivr_ST0_FT0,
1303 };
1304
1305 /* NOTE the exception in "r" op ordering */
1306 static GenOpFunc1 *gen_op_fp_arith_STN_ST0[8] = {
1307     gen_op_fadd_STN_ST0,
1308     gen_op_fmul_STN_ST0,
1309     NULL,
1310     NULL,
1311     gen_op_fsubr_STN_ST0,
1312     gen_op_fsub_STN_ST0,
1313     gen_op_fdivr_STN_ST0,
1314     gen_op_fdiv_STN_ST0,
1315 };
1316
1317 /* if d == OR_TMP0, it means memory operand (address in A0) */
1318 static void gen_op(DisasContext *s1, int op, int ot, int d)
1319 {
1320     GenOpFunc *gen_update_cc;
1321
1322     if (d != OR_TMP0) {
1323         gen_op_mov_TN_reg[ot][0][d]();
1324     } else {
1325         gen_op_ld_T0_A0[ot + s1->mem_index]();
1326     }
1327     switch(op) {
1328     case OP_ADCL:
1329     case OP_SBBL:
1330         if (s1->cc_op != CC_OP_DYNAMIC)
1331             gen_op_set_cc_op(s1->cc_op);
1332         if (d != OR_TMP0) {
1333             gen_op_arithc_T0_T1_cc[ot][op - OP_ADCL]();
1334             gen_op_mov_reg_T0[ot][d]();
1335         } else {
1336             gen_op_arithc_mem_T0_T1_cc[ot + s1->mem_index][op - OP_ADCL]();
1337         }
1338         s1->cc_op = CC_OP_DYNAMIC;
1339         goto the_end;
1340     case OP_ADDL:
1341         gen_op_addl_T0_T1();
1342         s1->cc_op = CC_OP_ADDB + ot;
1343         gen_update_cc = gen_op_update2_cc;
1344         break;
1345     case OP_SUBL:
1346         gen_op_subl_T0_T1();
1347         s1->cc_op = CC_OP_SUBB + ot;
1348         gen_update_cc = gen_op_update2_cc;
1349         break;
1350     default:
1351     case OP_ANDL:
1352     case OP_ORL:
1353     case OP_XORL:
1354         gen_op_arith_T0_T1_cc[op]();
1355         s1->cc_op = CC_OP_LOGICB + ot;
1356         gen_update_cc = gen_op_update1_cc;
1357         break;
1358     case OP_CMPL:
1359         gen_op_cmpl_T0_T1_cc();
1360         s1->cc_op = CC_OP_SUBB + ot;
1361         gen_update_cc = NULL;
1362         break;
1363     }
1364     if (op != OP_CMPL) {
1365         if (d != OR_TMP0)
1366             gen_op_mov_reg_T0[ot][d]();
1367         else
1368             gen_op_st_T0_A0[ot + s1->mem_index]();
1369     }
1370     /* the flags update must happen after the memory write (precise
1371        exception support) */
1372     if (gen_update_cc)
1373         gen_update_cc();
1374  the_end: ;
1375 }
1376
1377 /* if d == OR_TMP0, it means memory operand (address in A0) */
1378 static void gen_inc(DisasContext *s1, int ot, int d, int c)
1379 {
1380     if (d != OR_TMP0)
1381         gen_op_mov_TN_reg[ot][0][d]();
1382     else
1383         gen_op_ld_T0_A0[ot + s1->mem_index]();
1384     if (s1->cc_op != CC_OP_DYNAMIC)
1385         gen_op_set_cc_op(s1->cc_op);
1386     if (c > 0) {
1387         gen_op_incl_T0();
1388         s1->cc_op = CC_OP_INCB + ot;
1389     } else {
1390         gen_op_decl_T0();
1391         s1->cc_op = CC_OP_DECB + ot;
1392     }
1393     if (d != OR_TMP0)
1394         gen_op_mov_reg_T0[ot][d]();
1395     else
1396         gen_op_st_T0_A0[ot + s1->mem_index]();
1397     gen_op_update_inc_cc();
1398 }
1399
1400 static void gen_shift(DisasContext *s1, int op, int ot, int d, int s)
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 (s != OR_TMP1)
1407         gen_op_mov_TN_reg[ot][1][s]();
1408     /* for zero counts, flags are not updated, so must do it dynamically */
1409     if (s1->cc_op != CC_OP_DYNAMIC)
1410         gen_op_set_cc_op(s1->cc_op);
1411
1412     if (d != OR_TMP0)
1413         gen_op_shift_T0_T1_cc[ot][op]();
1414     else
1415         gen_op_shift_mem_T0_T1_cc[ot + s1->mem_index][op]();
1416     if (d != OR_TMP0)
1417         gen_op_mov_reg_T0[ot][d]();
1418     s1->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */
1419 }
1420
1421 static void gen_shifti(DisasContext *s1, int op, int ot, int d, int c)
1422 {
1423     /* currently not optimized */
1424     gen_op_movl_T1_im(c);
1425     gen_shift(s1, op, ot, d, OR_TMP1);
1426 }
1427
1428 static void gen_lea_modrm(DisasContext *s, int modrm, int *reg_ptr, int *offset_ptr)
1429 {
1430     target_long disp;
1431     int havesib;
1432     int base;
1433     int index;
1434     int scale;
1435     int opreg;
1436     int mod, rm, code, override, must_add_seg;
1437
1438     override = s->override;
1439     must_add_seg = s->addseg;
1440     if (override >= 0)
1441         must_add_seg = 1;
1442     mod = (modrm >> 6) & 3;
1443     rm = modrm & 7;
1444
1445     if (s->aflag) {
1446
1447         havesib = 0;
1448         base = rm;
1449         index = 0;
1450         scale = 0;
1451
1452         if (base == 4) {
1453             havesib = 1;
1454             code = ldub_code(s->pc++);
1455             scale = (code >> 6) & 3;
1456             index = ((code >> 3) & 7) | REX_X(s);
1457             base = (code & 7);
1458         }
1459         base |= REX_B(s);
1460
1461         switch (mod) {
1462         case 0:
1463             if ((base & 7) == 5) {
1464                 base = -1;
1465                 disp = (int32_t)ldl_code(s->pc);
1466                 s->pc += 4;
1467                 if (CODE64(s) && !havesib) {
1468                     disp += s->pc + s->rip_offset;
1469                 }
1470             } else {
1471                 disp = 0;
1472             }
1473             break;
1474         case 1:
1475             disp = (int8_t)ldub_code(s->pc++);
1476             break;
1477         default:
1478         case 2:
1479             disp = ldl_code(s->pc);
1480             s->pc += 4;
1481             break;
1482         }
1483
1484         if (base >= 0) {
1485             /* for correct popl handling with esp */
1486             if (base == 4 && s->popl_esp_hack)
1487                 disp += s->popl_esp_hack;
1488 #ifdef TARGET_X86_64
1489             if (s->aflag == 2) {
1490                 gen_op_movq_A0_reg[base]();
1491                 if (disp != 0) {
1492                     if ((int32_t)disp == disp)
1493                         gen_op_addq_A0_im(disp);
1494                     else
1495                         gen_op_addq_A0_im64(disp >> 32, disp);
1496                 }
1497             } else
1498 #endif
1499             {
1500                 gen_op_movl_A0_reg[base]();
1501                 if (disp != 0)
1502                     gen_op_addl_A0_im(disp);
1503             }
1504         } else {
1505 #ifdef TARGET_X86_64
1506             if (s->aflag == 2) {
1507                 if ((int32_t)disp == disp)
1508                     gen_op_movq_A0_im(disp);
1509                 else
1510                     gen_op_movq_A0_im64(disp >> 32, disp);
1511             } else
1512 #endif
1513             {
1514                 gen_op_movl_A0_im(disp);
1515             }
1516         }
1517         /* XXX: index == 4 is always invalid */
1518         if (havesib && (index != 4 || scale != 0)) {
1519 #ifdef TARGET_X86_64
1520             if (s->aflag == 2) {
1521                 gen_op_addq_A0_reg_sN[scale][index]();
1522             } else
1523 #endif
1524             {
1525                 gen_op_addl_A0_reg_sN[scale][index]();
1526             }
1527         }
1528         if (must_add_seg) {
1529             if (override < 0) {
1530                 if (base == R_EBP || base == R_ESP)
1531                     override = R_SS;
1532                 else
1533                     override = R_DS;
1534             }
1535 #ifdef TARGET_X86_64
1536             if (s->aflag == 2) {
1537                 gen_op_addq_A0_seg(offsetof(CPUX86State,segs[override].base));
1538             } else
1539 #endif
1540             {
1541                 gen_op_addl_A0_seg(offsetof(CPUX86State,segs[override].base));
1542             }
1543         }
1544     } else {
1545         switch (mod) {
1546         case 0:
1547             if (rm == 6) {
1548                 disp = lduw_code(s->pc);
1549                 s->pc += 2;
1550                 gen_op_movl_A0_im(disp);
1551                 rm = 0; /* avoid SS override */
1552                 goto no_rm;
1553             } else {
1554                 disp = 0;
1555             }
1556             break;
1557         case 1:
1558             disp = (int8_t)ldub_code(s->pc++);
1559             break;
1560         default:
1561         case 2:
1562             disp = lduw_code(s->pc);
1563             s->pc += 2;
1564             break;
1565         }
1566         switch(rm) {
1567         case 0:
1568             gen_op_movl_A0_reg[R_EBX]();
1569             gen_op_addl_A0_reg_sN[0][R_ESI]();
1570             break;
1571         case 1:
1572             gen_op_movl_A0_reg[R_EBX]();
1573             gen_op_addl_A0_reg_sN[0][R_EDI]();
1574             break;
1575         case 2:
1576             gen_op_movl_A0_reg[R_EBP]();
1577             gen_op_addl_A0_reg_sN[0][R_ESI]();
1578             break;
1579         case 3:
1580             gen_op_movl_A0_reg[R_EBP]();
1581             gen_op_addl_A0_reg_sN[0][R_EDI]();
1582             break;
1583         case 4:
1584             gen_op_movl_A0_reg[R_ESI]();
1585             break;
1586         case 5:
1587             gen_op_movl_A0_reg[R_EDI]();
1588             break;
1589         case 6:
1590             gen_op_movl_A0_reg[R_EBP]();
1591             break;
1592         default:
1593         case 7:
1594             gen_op_movl_A0_reg[R_EBX]();
1595             break;
1596         }
1597         if (disp != 0)
1598             gen_op_addl_A0_im(disp);
1599         gen_op_andl_A0_ffff();
1600     no_rm:
1601         if (must_add_seg) {
1602             if (override < 0) {
1603                 if (rm == 2 || rm == 3 || rm == 6)
1604                     override = R_SS;
1605                 else
1606                     override = R_DS;
1607             }
1608             gen_op_addl_A0_seg(offsetof(CPUX86State,segs[override].base));
1609         }
1610     }
1611
1612     opreg = OR_A0;
1613     disp = 0;
1614     *reg_ptr = opreg;
1615     *offset_ptr = disp;
1616 }
1617
1618 static void gen_nop_modrm(DisasContext *s, int modrm)
1619 {
1620     int mod, rm, base, code;
1621
1622     mod = (modrm >> 6) & 3;
1623     if (mod == 3)
1624         return;
1625     rm = modrm & 7;
1626
1627     if (s->aflag) {
1628
1629         base = rm;
1630
1631         if (base == 4) {
1632             code = ldub_code(s->pc++);
1633             base = (code & 7);
1634         }
1635
1636         switch (mod) {
1637         case 0:
1638             if (base == 5) {
1639                 s->pc += 4;
1640             }
1641             break;
1642         case 1:
1643             s->pc++;
1644             break;
1645         default:
1646         case 2:
1647             s->pc += 4;
1648             break;
1649         }
1650     } else {
1651         switch (mod) {
1652         case 0:
1653             if (rm == 6) {
1654                 s->pc += 2;
1655             }
1656             break;
1657         case 1:
1658             s->pc++;
1659             break;
1660         default:
1661         case 2:
1662             s->pc += 2;
1663             break;
1664         }
1665     }
1666 }
1667
1668 /* used for LEA and MOV AX, mem */
1669 static void gen_add_A0_ds_seg(DisasContext *s)
1670 {
1671     int override, must_add_seg;
1672     must_add_seg = s->addseg;
1673     override = R_DS;
1674     if (s->override >= 0) {
1675         override = s->override;
1676         must_add_seg = 1;
1677     } else {
1678         override = R_DS;
1679     }
1680     if (must_add_seg) {
1681 #ifdef TARGET_X86_64
1682         if (CODE64(s)) {
1683             gen_op_addq_A0_seg(offsetof(CPUX86State,segs[override].base));
1684         } else
1685 #endif
1686         {
1687             gen_op_addl_A0_seg(offsetof(CPUX86State,segs[override].base));
1688         }
1689     }
1690 }
1691
1692 /* generate modrm memory load or store of 'reg'. TMP0 is used if reg !=
1693    OR_TMP0 */
1694 static void gen_ldst_modrm(DisasContext *s, int modrm, int ot, int reg, int is_store)
1695 {
1696     int mod, rm, opreg, disp;
1697
1698     mod = (modrm >> 6) & 3;
1699     rm = (modrm & 7) | REX_B(s);
1700     if (mod == 3) {
1701         if (is_store) {
1702             if (reg != OR_TMP0)
1703                 gen_op_mov_TN_reg[ot][0][reg]();
1704             gen_op_mov_reg_T0[ot][rm]();
1705         } else {
1706             gen_op_mov_TN_reg[ot][0][rm]();
1707             if (reg != OR_TMP0)
1708                 gen_op_mov_reg_T0[ot][reg]();
1709         }
1710     } else {
1711         gen_lea_modrm(s, modrm, &opreg, &disp);
1712         if (is_store) {
1713             if (reg != OR_TMP0)
1714                 gen_op_mov_TN_reg[ot][0][reg]();
1715             gen_op_st_T0_A0[ot + s->mem_index]();
1716         } else {
1717             gen_op_ld_T0_A0[ot + s->mem_index]();
1718             if (reg != OR_TMP0)
1719                 gen_op_mov_reg_T0[ot][reg]();
1720         }
1721     }
1722 }
1723
1724 static inline uint32_t insn_get(DisasContext *s, int ot)
1725 {
1726     uint32_t ret;
1727
1728     switch(ot) {
1729     case OT_BYTE:
1730         ret = ldub_code(s->pc);
1731         s->pc++;
1732         break;
1733     case OT_WORD:
1734         ret = lduw_code(s->pc);
1735         s->pc += 2;
1736         break;
1737     default:
1738     case OT_LONG:
1739         ret = ldl_code(s->pc);
1740         s->pc += 4;
1741         break;
1742     }
1743     return ret;
1744 }
1745
1746 static inline int insn_const_size(unsigned int ot)
1747 {
1748     if (ot <= OT_LONG)
1749         return 1 << ot;
1750     else
1751         return 4;
1752 }
1753
1754 static inline void gen_goto_tb(DisasContext *s, int tb_num, target_ulong eip)
1755 {
1756     TranslationBlock *tb;
1757     target_ulong pc;
1758
1759     pc = s->cs_base + eip;
1760     tb = s->tb;
1761     /* NOTE: we handle the case where the TB spans two pages here */
1762     if ((pc & TARGET_PAGE_MASK) == (tb->pc & TARGET_PAGE_MASK) ||
1763         (pc & TARGET_PAGE_MASK) == ((s->pc - 1) & TARGET_PAGE_MASK))  {
1764         /* jump to same page: we can use a direct jump */
1765         if (tb_num == 0)
1766             gen_op_goto_tb0(TBPARAM(tb));
1767         else
1768             gen_op_goto_tb1(TBPARAM(tb));
1769         gen_jmp_im(eip);
1770         gen_op_movl_T0_im((long)tb + tb_num);
1771         gen_op_exit_tb();
1772     } else {
1773         /* jump to another page: currently not optimized */
1774         gen_jmp_im(eip);
1775         gen_eob(s);
1776     }
1777 }
1778
1779 static inline void gen_jcc(DisasContext *s, int b,
1780                            target_ulong val, target_ulong next_eip)
1781 {
1782     TranslationBlock *tb;
1783     int inv, jcc_op;
1784     GenOpFunc1 *func;
1785     target_ulong tmp;
1786     int l1, l2;
1787
1788     inv = b & 1;
1789     jcc_op = (b >> 1) & 7;
1790
1791     if (s->jmp_opt) {
1792         switch(s->cc_op) {
1793             /* we optimize the cmp/jcc case */
1794         case CC_OP_SUBB:
1795         case CC_OP_SUBW:
1796         case CC_OP_SUBL:
1797         case CC_OP_SUBQ:
1798             func = gen_jcc_sub[s->cc_op - CC_OP_SUBB][jcc_op];
1799             break;
1800
1801             /* some jumps are easy to compute */
1802         case CC_OP_ADDB:
1803         case CC_OP_ADDW:
1804         case CC_OP_ADDL:
1805         case CC_OP_ADDQ:
1806
1807         case CC_OP_ADCB:
1808         case CC_OP_ADCW:
1809         case CC_OP_ADCL:
1810         case CC_OP_ADCQ:
1811
1812         case CC_OP_SBBB:
1813         case CC_OP_SBBW:
1814         case CC_OP_SBBL:
1815         case CC_OP_SBBQ:
1816
1817         case CC_OP_LOGICB:
1818         case CC_OP_LOGICW:
1819         case CC_OP_LOGICL:
1820         case CC_OP_LOGICQ:
1821
1822         case CC_OP_INCB:
1823         case CC_OP_INCW:
1824         case CC_OP_INCL:
1825         case CC_OP_INCQ:
1826
1827         case CC_OP_DECB:
1828         case CC_OP_DECW:
1829         case CC_OP_DECL:
1830         case CC_OP_DECQ:
1831
1832         case CC_OP_SHLB:
1833         case CC_OP_SHLW:
1834         case CC_OP_SHLL:
1835         case CC_OP_SHLQ:
1836
1837         case CC_OP_SARB:
1838         case CC_OP_SARW:
1839         case CC_OP_SARL:
1840         case CC_OP_SARQ:
1841             switch(jcc_op) {
1842             case JCC_Z:
1843                 func = gen_jcc_sub[(s->cc_op - CC_OP_ADDB) % 4][jcc_op];
1844                 break;
1845             case JCC_S:
1846                 func = gen_jcc_sub[(s->cc_op - CC_OP_ADDB) % 4][jcc_op];
1847                 break;
1848             default:
1849                 func = NULL;
1850                 break;
1851             }
1852             break;
1853         default:
1854             func = NULL;
1855             break;
1856         }
1857
1858         if (s->cc_op != CC_OP_DYNAMIC) {
1859             gen_op_set_cc_op(s->cc_op);
1860             s->cc_op = CC_OP_DYNAMIC;
1861         }
1862
1863         if (!func) {
1864             gen_setcc_slow[jcc_op]();
1865             func = gen_op_jnz_T0_label;
1866         }
1867
1868         if (inv) {
1869             tmp = val;
1870             val = next_eip;
1871             next_eip = tmp;
1872         }
1873         tb = s->tb;
1874
1875         l1 = gen_new_label();
1876         func(l1);
1877
1878         gen_goto_tb(s, 0, next_eip);
1879
1880         gen_set_label(l1);
1881         gen_goto_tb(s, 1, val);
1882
1883         s->is_jmp = 3;
1884     } else {
1885
1886         if (s->cc_op != CC_OP_DYNAMIC) {
1887             gen_op_set_cc_op(s->cc_op);
1888             s->cc_op = CC_OP_DYNAMIC;
1889         }
1890         gen_setcc_slow[jcc_op]();
1891         if (inv) {
1892             tmp = val;
1893             val = next_eip;
1894             next_eip = tmp;
1895         }
1896         l1 = gen_new_label();
1897         l2 = gen_new_label();
1898         gen_op_jnz_T0_label(l1);
1899         gen_jmp_im(next_eip);
1900         gen_op_jmp_label(l2);
1901         gen_set_label(l1);
1902         gen_jmp_im(val);
1903         gen_set_label(l2);
1904         gen_eob(s);
1905     }
1906 }
1907
1908 static void gen_setcc(DisasContext *s, int b)
1909 {
1910     int inv, jcc_op;
1911     GenOpFunc *func;
1912
1913     inv = b & 1;
1914     jcc_op = (b >> 1) & 7;
1915     switch(s->cc_op) {
1916         /* we optimize the cmp/jcc case */
1917     case CC_OP_SUBB:
1918     case CC_OP_SUBW:
1919     case CC_OP_SUBL:
1920     case CC_OP_SUBQ:
1921         func = gen_setcc_sub[s->cc_op - CC_OP_SUBB][jcc_op];
1922         if (!func)
1923             goto slow_jcc;
1924         break;
1925
1926         /* some jumps are easy to compute */
1927     case CC_OP_ADDB:
1928     case CC_OP_ADDW:
1929     case CC_OP_ADDL:
1930     case CC_OP_ADDQ:
1931
1932     case CC_OP_LOGICB:
1933     case CC_OP_LOGICW:
1934     case CC_OP_LOGICL:
1935     case CC_OP_LOGICQ:
1936
1937     case CC_OP_INCB:
1938     case CC_OP_INCW:
1939     case CC_OP_INCL:
1940     case CC_OP_INCQ:
1941
1942     case CC_OP_DECB:
1943     case CC_OP_DECW:
1944     case CC_OP_DECL:
1945     case CC_OP_DECQ:
1946
1947     case CC_OP_SHLB:
1948     case CC_OP_SHLW:
1949     case CC_OP_SHLL:
1950     case CC_OP_SHLQ:
1951         switch(jcc_op) {
1952         case JCC_Z:
1953             func = gen_setcc_sub[(s->cc_op - CC_OP_ADDB) % 4][jcc_op];
1954             break;
1955         case JCC_S:
1956             func = gen_setcc_sub[(s->cc_op - CC_OP_ADDB) % 4][jcc_op];
1957             break;
1958         default:
1959             goto slow_jcc;
1960         }
1961         break;
1962     default:
1963     slow_jcc:
1964         if (s->cc_op != CC_OP_DYNAMIC)
1965             gen_op_set_cc_op(s->cc_op);
1966         func = gen_setcc_slow[jcc_op];
1967         break;
1968     }
1969     func();
1970     if (inv) {
1971         gen_op_xor_T0_1();
1972     }
1973 }
1974
1975 /* move T0 to seg_reg and compute if the CPU state may change. Never
1976    call this function with seg_reg == R_CS */
1977 static void gen_movl_seg_T0(DisasContext *s, int seg_reg, target_ulong cur_eip)
1978 {
1979     if (s->pe && !s->vm86) {
1980         /* XXX: optimize by finding processor state dynamically */
1981         if (s->cc_op != CC_OP_DYNAMIC)
1982             gen_op_set_cc_op(s->cc_op);
1983         gen_jmp_im(cur_eip);
1984         gen_op_movl_seg_T0(seg_reg);
1985         /* abort translation because the addseg value may change or
1986            because ss32 may change. For R_SS, translation must always
1987            stop as a special handling must be done to disable hardware
1988            interrupts for the next instruction */
1989         if (seg_reg == R_SS || (s->code32 && seg_reg < R_FS))
1990             s->is_jmp = 3;
1991     } else {
1992         gen_op_movl_seg_T0_vm(offsetof(CPUX86State,segs[seg_reg]));
1993         if (seg_reg == R_SS)
1994             s->is_jmp = 3;
1995     }
1996 }
1997
1998 #ifdef TARGET_X86_64
1999 #define SVM_movq_T1_im(x) gen_op_movq_T1_im64((x) >> 32, x)
2000 #else
2001 #define SVM_movq_T1_im(x) gen_op_movl_T1_im(x)
2002 #endif
2003
2004 static inline int
2005 gen_svm_check_io(DisasContext *s, target_ulong pc_start, uint64_t type)
2006 {
2007 #if !defined(CONFIG_USER_ONLY)
2008     if(s->flags & (1ULL << INTERCEPT_IOIO_PROT)) {
2009         if (s->cc_op != CC_OP_DYNAMIC)
2010             gen_op_set_cc_op(s->cc_op);
2011         SVM_movq_T1_im(s->pc - s->cs_base);
2012         gen_jmp_im(pc_start - s->cs_base);
2013         gen_op_geneflags();
2014         gen_op_svm_check_intercept_io((uint32_t)(type >> 32), (uint32_t)type);
2015         s->cc_op = CC_OP_DYNAMIC;
2016         /* FIXME: maybe we could move the io intercept vector to the TB as well
2017                   so we know if this is an EOB or not ... let's assume it's not
2018                   for now. */
2019     }
2020 #endif
2021     return 0;
2022 }
2023
2024 static inline int svm_is_rep(int prefixes)
2025 {
2026     return ((prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) ? 8 : 0);
2027 }
2028
2029 static inline int
2030 gen_svm_check_intercept_param(DisasContext *s, target_ulong pc_start,
2031                               uint64_t type, uint64_t param)
2032 {
2033     if(!(s->flags & (INTERCEPT_SVM_MASK)))
2034         /* no SVM activated */
2035         return 0;
2036     switch(type) {
2037         /* CRx and DRx reads/writes */
2038         case SVM_EXIT_READ_CR0 ... SVM_EXIT_EXCP_BASE - 1:
2039             if (s->cc_op != CC_OP_DYNAMIC) {
2040                 gen_op_set_cc_op(s->cc_op);
2041                 s->cc_op = CC_OP_DYNAMIC;
2042             }
2043             gen_jmp_im(pc_start - s->cs_base);
2044             SVM_movq_T1_im(param);
2045             gen_op_geneflags();
2046             gen_op_svm_check_intercept_param((uint32_t)(type >> 32), (uint32_t)type);
2047             /* this is a special case as we do not know if the interception occurs
2048                so we assume there was none */
2049             return 0;
2050         case SVM_EXIT_MSR:
2051             if(s->flags & (1ULL << INTERCEPT_MSR_PROT)) {
2052                 if (s->cc_op != CC_OP_DYNAMIC) {
2053                     gen_op_set_cc_op(s->cc_op);
2054                     s->cc_op = CC_OP_DYNAMIC;
2055                 }
2056                 gen_jmp_im(pc_start - s->cs_base);
2057                 SVM_movq_T1_im(param);
2058                 gen_op_geneflags();
2059                 gen_op_svm_check_intercept_param((uint32_t)(type >> 32), (uint32_t)type);
2060                 /* this is a special case as we do not know if the interception occurs
2061                    so we assume there was none */
2062                 return 0;
2063             }
2064             break;
2065         default:
2066             if(s->flags & (1ULL << ((type - SVM_EXIT_INTR) + INTERCEPT_INTR))) {
2067                 if (s->cc_op != CC_OP_DYNAMIC) {
2068                     gen_op_set_cc_op(s->cc_op);
2069                     s->cc_op = CC_OP_EFLAGS;
2070                 }
2071                 gen_jmp_im(pc_start - s->cs_base);
2072                 SVM_movq_T1_im(param);
2073                 gen_op_geneflags();
2074                 gen_op_svm_vmexit(type >> 32, type);
2075                 /* we can optimize this one so TBs don't get longer
2076                    than up to vmexit */
2077                 gen_eob(s);
2078                 return 1;
2079             }
2080     }
2081     return 0;
2082 }
2083
2084 static inline int
2085 gen_svm_check_intercept(DisasContext *s, target_ulong pc_start, uint64_t type)
2086 {
2087     return gen_svm_check_intercept_param(s, pc_start, type, 0);
2088 }
2089
2090 static inline void gen_stack_update(DisasContext *s, int addend)
2091 {
2092 #ifdef TARGET_X86_64
2093     if (CODE64(s)) {
2094         if (addend == 8)
2095             gen_op_addq_ESP_8();
2096         else
2097             gen_op_addq_ESP_im(addend);
2098     } else
2099 #endif
2100     if (s->ss32) {
2101         if (addend == 2)
2102             gen_op_addl_ESP_2();
2103         else if (addend == 4)
2104             gen_op_addl_ESP_4();
2105         else
2106             gen_op_addl_ESP_im(addend);
2107     } else {
2108         if (addend == 2)
2109             gen_op_addw_ESP_2();
2110         else if (addend == 4)
2111             gen_op_addw_ESP_4();
2112         else
2113             gen_op_addw_ESP_im(addend);
2114     }
2115 }
2116
2117 /* generate a push. It depends on ss32, addseg and dflag */
2118 static void gen_push_T0(DisasContext *s)
2119 {
2120 #ifdef TARGET_X86_64
2121     if (CODE64(s)) {
2122         gen_op_movq_A0_reg[R_ESP]();
2123         if (s->dflag) {
2124             gen_op_subq_A0_8();
2125             gen_op_st_T0_A0[OT_QUAD + s->mem_index]();
2126         } else {
2127             gen_op_subq_A0_2();
2128             gen_op_st_T0_A0[OT_WORD + s->mem_index]();
2129         }
2130         gen_op_movq_ESP_A0();
2131     } else
2132 #endif
2133     {
2134         gen_op_movl_A0_reg[R_ESP]();
2135         if (!s->dflag)
2136             gen_op_subl_A0_2();
2137         else
2138             gen_op_subl_A0_4();
2139         if (s->ss32) {
2140             if (s->addseg) {
2141                 gen_op_movl_T1_A0();
2142                 gen_op_addl_A0_SS();
2143             }
2144         } else {
2145             gen_op_andl_A0_ffff();
2146             gen_op_movl_T1_A0();
2147             gen_op_addl_A0_SS();
2148         }
2149         gen_op_st_T0_A0[s->dflag + 1 + s->mem_index]();
2150         if (s->ss32 && !s->addseg)
2151             gen_op_movl_ESP_A0();
2152         else
2153             gen_op_mov_reg_T1[s->ss32 + 1][R_ESP]();
2154     }
2155 }
2156
2157 /* generate a push. It depends on ss32, addseg and dflag */
2158 /* slower version for T1, only used for call Ev */
2159 static void gen_push_T1(DisasContext *s)
2160 {
2161 #ifdef TARGET_X86_64
2162     if (CODE64(s)) {
2163         gen_op_movq_A0_reg[R_ESP]();
2164         if (s->dflag) {
2165             gen_op_subq_A0_8();
2166             gen_op_st_T1_A0[OT_QUAD + s->mem_index]();
2167         } else {
2168             gen_op_subq_A0_2();
2169             gen_op_st_T0_A0[OT_WORD + s->mem_index]();
2170         }
2171         gen_op_movq_ESP_A0();
2172     } else
2173 #endif
2174     {
2175         gen_op_movl_A0_reg[R_ESP]();
2176         if (!s->dflag)
2177             gen_op_subl_A0_2();
2178         else
2179             gen_op_subl_A0_4();
2180         if (s->ss32) {
2181             if (s->addseg) {
2182                 gen_op_addl_A0_SS();
2183             }
2184         } else {
2185             gen_op_andl_A0_ffff();
2186             gen_op_addl_A0_SS();
2187         }
2188         gen_op_st_T1_A0[s->dflag + 1 + s->mem_index]();
2189
2190         if (s->ss32 && !s->addseg)
2191             gen_op_movl_ESP_A0();
2192         else
2193             gen_stack_update(s, (-2) << s->dflag);
2194     }
2195 }
2196
2197 /* two step pop is necessary for precise exceptions */
2198 static void gen_pop_T0(DisasContext *s)
2199 {
2200 #ifdef TARGET_X86_64
2201     if (CODE64(s)) {
2202         gen_op_movq_A0_reg[R_ESP]();
2203         gen_op_ld_T0_A0[(s->dflag ? OT_QUAD : OT_WORD) + s->mem_index]();
2204     } else
2205 #endif
2206     {
2207         gen_op_movl_A0_reg[R_ESP]();
2208         if (s->ss32) {
2209             if (s->addseg)
2210                 gen_op_addl_A0_SS();
2211         } else {
2212             gen_op_andl_A0_ffff();
2213             gen_op_addl_A0_SS();
2214         }
2215         gen_op_ld_T0_A0[s->dflag + 1 + s->mem_index]();
2216     }
2217 }
2218
2219 static void gen_pop_update(DisasContext *s)
2220 {
2221 #ifdef TARGET_X86_64
2222     if (CODE64(s) && s->dflag) {
2223         gen_stack_update(s, 8);
2224     } else
2225 #endif
2226     {
2227         gen_stack_update(s, 2 << s->dflag);
2228     }
2229 }
2230
2231 static void gen_stack_A0(DisasContext *s)
2232 {
2233     gen_op_movl_A0_ESP();
2234     if (!s->ss32)
2235         gen_op_andl_A0_ffff();
2236     gen_op_movl_T1_A0();
2237     if (s->addseg)
2238         gen_op_addl_A0_seg(offsetof(CPUX86State,segs[R_SS].base));
2239 }
2240
2241 /* NOTE: wrap around in 16 bit not fully handled */
2242 static void gen_pusha(DisasContext *s)
2243 {
2244     int i;
2245     gen_op_movl_A0_ESP();
2246     gen_op_addl_A0_im(-16 <<  s->dflag);
2247     if (!s->ss32)
2248         gen_op_andl_A0_ffff();
2249     gen_op_movl_T1_A0();
2250     if (s->addseg)
2251         gen_op_addl_A0_seg(offsetof(CPUX86State,segs[R_SS].base));
2252     for(i = 0;i < 8; i++) {
2253         gen_op_mov_TN_reg[OT_LONG][0][7 - i]();
2254         gen_op_st_T0_A0[OT_WORD + s->dflag + s->mem_index]();
2255         gen_op_addl_A0_im(2 <<  s->dflag);
2256     }
2257     gen_op_mov_reg_T1[OT_WORD + s->ss32][R_ESP]();
2258 }
2259
2260 /* NOTE: wrap around in 16 bit not fully handled */
2261 static void gen_popa(DisasContext *s)
2262 {
2263     int i;
2264     gen_op_movl_A0_ESP();
2265     if (!s->ss32)
2266         gen_op_andl_A0_ffff();
2267     gen_op_movl_T1_A0();
2268     gen_op_addl_T1_im(16 <<  s->dflag);
2269     if (s->addseg)
2270         gen_op_addl_A0_seg(offsetof(CPUX86State,segs[R_SS].base));
2271     for(i = 0;i < 8; i++) {
2272         /* ESP is not reloaded */
2273         if (i != 3) {
2274             gen_op_ld_T0_A0[OT_WORD + s->dflag + s->mem_index]();
2275             gen_op_mov_reg_T0[OT_WORD + s->dflag][7 - i]();
2276         }
2277         gen_op_addl_A0_im(2 <<  s->dflag);
2278     }
2279     gen_op_mov_reg_T1[OT_WORD + s->ss32][R_ESP]();
2280 }
2281
2282 static void gen_enter(DisasContext *s, int esp_addend, int level)
2283 {
2284     int ot, opsize;
2285
2286     level &= 0x1f;
2287 #ifdef TARGET_X86_64
2288     if (CODE64(s)) {
2289         ot = s->dflag ? OT_QUAD : OT_WORD;
2290         opsize = 1 << ot;
2291
2292         gen_op_movl_A0_ESP();
2293         gen_op_addq_A0_im(-opsize);
2294         gen_op_movl_T1_A0();
2295
2296         /* push bp */
2297         gen_op_mov_TN_reg[OT_LONG][0][R_EBP]();
2298         gen_op_st_T0_A0[ot + s->mem_index]();
2299         if (level) {
2300             gen_op_enter64_level(level, (ot == OT_QUAD));
2301         }
2302         gen_op_mov_reg_T1[ot][R_EBP]();
2303         gen_op_addl_T1_im( -esp_addend + (-opsize * level) );
2304         gen_op_mov_reg_T1[OT_QUAD][R_ESP]();
2305     } else
2306 #endif
2307     {
2308         ot = s->dflag + OT_WORD;
2309         opsize = 2 << s->dflag;
2310
2311         gen_op_movl_A0_ESP();
2312         gen_op_addl_A0_im(-opsize);
2313         if (!s->ss32)
2314             gen_op_andl_A0_ffff();
2315         gen_op_movl_T1_A0();
2316         if (s->addseg)
2317             gen_op_addl_A0_seg(offsetof(CPUX86State,segs[R_SS].base));
2318         /* push bp */
2319         gen_op_mov_TN_reg[OT_LONG][0][R_EBP]();
2320         gen_op_st_T0_A0[ot + s->mem_index]();
2321         if (level) {
2322             gen_op_enter_level(level, s->dflag);
2323         }
2324         gen_op_mov_reg_T1[ot][R_EBP]();
2325         gen_op_addl_T1_im( -esp_addend + (-opsize * level) );
2326         gen_op_mov_reg_T1[OT_WORD + s->ss32][R_ESP]();
2327     }
2328 }
2329
2330 static void gen_exception(DisasContext *s, int trapno, target_ulong cur_eip)
2331 {
2332     if (s->cc_op != CC_OP_DYNAMIC)
2333         gen_op_set_cc_op(s->cc_op);
2334     gen_jmp_im(cur_eip);
2335     gen_op_raise_exception(trapno);
2336     s->is_jmp = 3;
2337 }
2338
2339 /* an interrupt is different from an exception because of the
2340    privilege checks */
2341 static void gen_interrupt(DisasContext *s, int intno,
2342                           target_ulong cur_eip, target_ulong next_eip)
2343 {
2344     if (s->cc_op != CC_OP_DYNAMIC)
2345         gen_op_set_cc_op(s->cc_op);
2346     gen_jmp_im(cur_eip);
2347     gen_op_raise_interrupt(intno, (int)(next_eip - cur_eip));
2348     s->is_jmp = 3;
2349 }
2350
2351 static void gen_debug(DisasContext *s, target_ulong cur_eip)
2352 {
2353     if (s->cc_op != CC_OP_DYNAMIC)
2354         gen_op_set_cc_op(s->cc_op);
2355     gen_jmp_im(cur_eip);
2356     gen_op_debug();
2357     s->is_jmp = 3;
2358 }
2359
2360 /* generate a generic end of block. Trace exception is also generated
2361    if needed */
2362 static void gen_eob(DisasContext *s)
2363 {
2364     if (s->cc_op != CC_OP_DYNAMIC)
2365         gen_op_set_cc_op(s->cc_op);
2366     if (s->tb->flags & HF_INHIBIT_IRQ_MASK) {
2367         gen_op_reset_inhibit_irq();
2368     }
2369     if (s->singlestep_enabled) {
2370         gen_op_debug();
2371     } else if (s->tf) {
2372         gen_op_single_step();
2373     } else {
2374         gen_op_movl_T0_0();
2375         gen_op_exit_tb();
2376     }
2377     s->is_jmp = 3;
2378 }
2379
2380 /* generate a jump to eip. No segment change must happen before as a
2381    direct call to the next block may occur */
2382 static void gen_jmp_tb(DisasContext *s, target_ulong eip, int tb_num)
2383 {
2384     if (s->jmp_opt) {
2385         if (s->cc_op != CC_OP_DYNAMIC) {
2386             gen_op_set_cc_op(s->cc_op);
2387             s->cc_op = CC_OP_DYNAMIC;
2388         }
2389         gen_goto_tb(s, tb_num, eip);
2390         s->is_jmp = 3;
2391     } else {
2392         gen_jmp_im(eip);
2393         gen_eob(s);
2394     }
2395 }
2396
2397 static void gen_jmp(DisasContext *s, target_ulong eip)
2398 {
2399     gen_jmp_tb(s, eip, 0);
2400 }
2401
2402 static void gen_movtl_T0_im(target_ulong val)
2403 {
2404 #ifdef TARGET_X86_64
2405     if ((int32_t)val == val) {
2406         gen_op_movl_T0_im(val);
2407     } else {
2408         gen_op_movq_T0_im64(val >> 32, val);
2409     }
2410 #else
2411     gen_op_movl_T0_im(val);
2412 #endif
2413 }
2414
2415 static void gen_movtl_T1_im(target_ulong val)
2416 {
2417 #ifdef TARGET_X86_64
2418     if ((int32_t)val == val) {
2419         gen_op_movl_T1_im(val);
2420     } else {
2421         gen_op_movq_T1_im64(val >> 32, val);
2422     }
2423 #else
2424     gen_op_movl_T1_im(val);
2425 #endif
2426 }
2427
2428 static void gen_add_A0_im(DisasContext *s, int val)
2429 {
2430 #ifdef TARGET_X86_64
2431     if (CODE64(s))
2432         gen_op_addq_A0_im(val);
2433     else
2434 #endif
2435         gen_op_addl_A0_im(val);
2436 }
2437
2438 static GenOpFunc1 *gen_ldq_env_A0[3] = {
2439     gen_op_ldq_raw_env_A0,
2440 #ifndef CONFIG_USER_ONLY
2441     gen_op_ldq_kernel_env_A0,
2442     gen_op_ldq_user_env_A0,
2443 #endif
2444 };
2445
2446 static GenOpFunc1 *gen_stq_env_A0[3] = {
2447     gen_op_stq_raw_env_A0,
2448 #ifndef CONFIG_USER_ONLY
2449     gen_op_stq_kernel_env_A0,
2450     gen_op_stq_user_env_A0,
2451 #endif
2452 };
2453
2454 static GenOpFunc1 *gen_ldo_env_A0[3] = {
2455     gen_op_ldo_raw_env_A0,
2456 #ifndef CONFIG_USER_ONLY
2457     gen_op_ldo_kernel_env_A0,
2458     gen_op_ldo_user_env_A0,
2459 #endif
2460 };
2461
2462 static GenOpFunc1 *gen_sto_env_A0[3] = {
2463     gen_op_sto_raw_env_A0,
2464 #ifndef CONFIG_USER_ONLY
2465     gen_op_sto_kernel_env_A0,
2466     gen_op_sto_user_env_A0,
2467 #endif
2468 };
2469
2470 #define SSE_SPECIAL ((GenOpFunc2 *)1)
2471
2472 #define MMX_OP2(x) { gen_op_ ## x ## _mmx, gen_op_ ## x ## _xmm }
2473 #define SSE_FOP(x) { gen_op_ ## x ## ps, gen_op_ ## x ## pd, \
2474                      gen_op_ ## x ## ss, gen_op_ ## x ## sd, }
2475
2476 static GenOpFunc2 *sse_op_table1[256][4] = {
2477     /* pure SSE operations */
2478     [0x10] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movups, movupd, movss, movsd */
2479     [0x11] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movups, movupd, movss, movsd */
2480     [0x12] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movlps, movlpd, movsldup, movddup */
2481     [0x13] = { SSE_SPECIAL, SSE_SPECIAL },  /* movlps, movlpd */
2482     [0x14] = { gen_op_punpckldq_xmm, gen_op_punpcklqdq_xmm },
2483     [0x15] = { gen_op_punpckhdq_xmm, gen_op_punpckhqdq_xmm },
2484     [0x16] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL },  /* movhps, movhpd, movshdup */
2485     [0x17] = { SSE_SPECIAL, SSE_SPECIAL },  /* movhps, movhpd */
2486
2487     [0x28] = { SSE_SPECIAL, SSE_SPECIAL },  /* movaps, movapd */
2488     [0x29] = { SSE_SPECIAL, SSE_SPECIAL },  /* movaps, movapd */
2489     [0x2a] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* cvtpi2ps, cvtpi2pd, cvtsi2ss, cvtsi2sd */
2490     [0x2b] = { SSE_SPECIAL, SSE_SPECIAL },  /* movntps, movntpd */
2491     [0x2c] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* cvttps2pi, cvttpd2pi, cvttsd2si, cvttss2si */
2492     [0x2d] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* cvtps2pi, cvtpd2pi, cvtsd2si, cvtss2si */
2493     [0x2e] = { gen_op_ucomiss, gen_op_ucomisd },
2494     [0x2f] = { gen_op_comiss, gen_op_comisd },
2495     [0x50] = { SSE_SPECIAL, SSE_SPECIAL }, /* movmskps, movmskpd */
2496     [0x51] = SSE_FOP(sqrt),
2497     [0x52] = { gen_op_rsqrtps, NULL, gen_op_rsqrtss, NULL },
2498     [0x53] = { gen_op_rcpps, NULL, gen_op_rcpss, NULL },
2499     [0x54] = { gen_op_pand_xmm, gen_op_pand_xmm }, /* andps, andpd */
2500     [0x55] = { gen_op_pandn_xmm, gen_op_pandn_xmm }, /* andnps, andnpd */
2501     [0x56] = { gen_op_por_xmm, gen_op_por_xmm }, /* orps, orpd */
2502     [0x57] = { gen_op_pxor_xmm, gen_op_pxor_xmm }, /* xorps, xorpd */
2503     [0x58] = SSE_FOP(add),
2504     [0x59] = SSE_FOP(mul),
2505     [0x5a] = { gen_op_cvtps2pd, gen_op_cvtpd2ps,
2506                gen_op_cvtss2sd, gen_op_cvtsd2ss },
2507     [0x5b] = { gen_op_cvtdq2ps, gen_op_cvtps2dq, gen_op_cvttps2dq },
2508     [0x5c] = SSE_FOP(sub),
2509     [0x5d] = SSE_FOP(min),
2510     [0x5e] = SSE_FOP(div),
2511     [0x5f] = SSE_FOP(max),
2512
2513     [0xc2] = SSE_FOP(cmpeq),
2514     [0xc6] = { (GenOpFunc2 *)gen_op_shufps, (GenOpFunc2 *)gen_op_shufpd },
2515
2516     /* MMX ops and their SSE extensions */
2517     [0x60] = MMX_OP2(punpcklbw),
2518     [0x61] = MMX_OP2(punpcklwd),
2519     [0x62] = MMX_OP2(punpckldq),
2520     [0x63] = MMX_OP2(packsswb),
2521     [0x64] = MMX_OP2(pcmpgtb),
2522     [0x65] = MMX_OP2(pcmpgtw),
2523     [0x66] = MMX_OP2(pcmpgtl),
2524     [0x67] = MMX_OP2(packuswb),
2525     [0x68] = MMX_OP2(punpckhbw),
2526     [0x69] = MMX_OP2(punpckhwd),
2527     [0x6a] = MMX_OP2(punpckhdq),
2528     [0x6b] = MMX_OP2(packssdw),
2529     [0x6c] = { NULL, gen_op_punpcklqdq_xmm },
2530     [0x6d] = { NULL, gen_op_punpckhqdq_xmm },
2531     [0x6e] = { SSE_SPECIAL, SSE_SPECIAL }, /* movd mm, ea */
2532     [0x6f] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movq, movdqa, , movqdu */
2533     [0x70] = { (GenOpFunc2 *)gen_op_pshufw_mmx,
2534                (GenOpFunc2 *)gen_op_pshufd_xmm,
2535                (GenOpFunc2 *)gen_op_pshufhw_xmm,
2536                (GenOpFunc2 *)gen_op_pshuflw_xmm },
2537     [0x71] = { SSE_SPECIAL, SSE_SPECIAL }, /* shiftw */
2538     [0x72] = { SSE_SPECIAL, SSE_SPECIAL }, /* shiftd */
2539     [0x73] = { SSE_SPECIAL, SSE_SPECIAL }, /* shiftq */
2540     [0x74] = MMX_OP2(pcmpeqb),
2541     [0x75] = MMX_OP2(pcmpeqw),
2542     [0x76] = MMX_OP2(pcmpeql),
2543     [0x77] = { SSE_SPECIAL }, /* emms */
2544     [0x7c] = { NULL, gen_op_haddpd, NULL, gen_op_haddps },
2545     [0x7d] = { NULL, gen_op_hsubpd, NULL, gen_op_hsubps },
2546     [0x7e] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movd, movd, , movq */
2547     [0x7f] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movq, movdqa, movdqu */
2548     [0xc4] = { SSE_SPECIAL, SSE_SPECIAL }, /* pinsrw */
2549     [0xc5] = { SSE_SPECIAL, SSE_SPECIAL }, /* pextrw */
2550     [0xd0] = { NULL, gen_op_addsubpd, NULL, gen_op_addsubps },
2551     [0xd1] = MMX_OP2(psrlw),
2552     [0xd2] = MMX_OP2(psrld),
2553     [0xd3] = MMX_OP2(psrlq),
2554     [0xd4] = MMX_OP2(paddq),
2555     [0xd5] = MMX_OP2(pmullw),
2556     [0xd6] = { NULL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL },
2557     [0xd7] = { SSE_SPECIAL, SSE_SPECIAL }, /* pmovmskb */
2558     [0xd8] = MMX_OP2(psubusb),
2559     [0xd9] = MMX_OP2(psubusw),
2560     [0xda] = MMX_OP2(pminub),
2561     [0xdb] = MMX_OP2(pand),
2562     [0xdc] = MMX_OP2(paddusb),
2563     [0xdd] = MMX_OP2(paddusw),
2564     [0xde] = MMX_OP2(pmaxub),
2565     [0xdf] = MMX_OP2(pandn),
2566     [0xe0] = MMX_OP2(pavgb),
2567     [0xe1] = MMX_OP2(psraw),
2568     [0xe2] = MMX_OP2(psrad),
2569     [0xe3] = MMX_OP2(pavgw),
2570     [0xe4] = MMX_OP2(pmulhuw),
2571     [0xe5] = MMX_OP2(pmulhw),
2572     [0xe6] = { NULL, gen_op_cvttpd2dq, gen_op_cvtdq2pd, gen_op_cvtpd2dq },
2573     [0xe7] = { SSE_SPECIAL , SSE_SPECIAL },  /* movntq, movntq */
2574     [0xe8] = MMX_OP2(psubsb),
2575     [0xe9] = MMX_OP2(psubsw),
2576     [0xea] = MMX_OP2(pminsw),
2577     [0xeb] = MMX_OP2(por),
2578     [0xec] = MMX_OP2(paddsb),
2579     [0xed] = MMX_OP2(paddsw),
2580     [0xee] = MMX_OP2(pmaxsw),
2581     [0xef] = MMX_OP2(pxor),
2582     [0xf0] = { NULL, NULL, NULL, SSE_SPECIAL }, /* lddqu */
2583     [0xf1] = MMX_OP2(psllw),
2584     [0xf2] = MMX_OP2(pslld),
2585     [0xf3] = MMX_OP2(psllq),
2586     [0xf4] = MMX_OP2(pmuludq),
2587     [0xf5] = MMX_OP2(pmaddwd),
2588     [0xf6] = MMX_OP2(psadbw),
2589     [0xf7] = MMX_OP2(maskmov),
2590     [0xf8] = MMX_OP2(psubb),
2591     [0xf9] = MMX_OP2(psubw),
2592     [0xfa] = MMX_OP2(psubl),
2593     [0xfb] = MMX_OP2(psubq),
2594     [0xfc] = MMX_OP2(paddb),
2595     [0xfd] = MMX_OP2(paddw),
2596     [0xfe] = MMX_OP2(paddl),
2597 };
2598
2599 static GenOpFunc2 *sse_op_table2[3 * 8][2] = {
2600     [0 + 2] = MMX_OP2(psrlw),
2601     [0 + 4] = MMX_OP2(psraw),
2602     [0 + 6] = MMX_OP2(psllw),
2603     [8 + 2] = MMX_OP2(psrld),
2604     [8 + 4] = MMX_OP2(psrad),
2605     [8 + 6] = MMX_OP2(pslld),
2606     [16 + 2] = MMX_OP2(psrlq),
2607     [16 + 3] = { NULL, gen_op_psrldq_xmm },
2608     [16 + 6] = MMX_OP2(psllq),
2609     [16 + 7] = { NULL, gen_op_pslldq_xmm },
2610 };
2611
2612 static GenOpFunc1 *sse_op_table3[4 * 3] = {
2613     gen_op_cvtsi2ss,
2614     gen_op_cvtsi2sd,
2615     X86_64_ONLY(gen_op_cvtsq2ss),
2616     X86_64_ONLY(gen_op_cvtsq2sd),
2617
2618     gen_op_cvttss2si,
2619     gen_op_cvttsd2si,
2620     X86_64_ONLY(gen_op_cvttss2sq),
2621     X86_64_ONLY(gen_op_cvttsd2sq),
2622
2623     gen_op_cvtss2si,
2624     gen_op_cvtsd2si,
2625     X86_64_ONLY(gen_op_cvtss2sq),
2626     X86_64_ONLY(gen_op_cvtsd2sq),
2627 };
2628
2629 static GenOpFunc2 *sse_op_table4[8][4] = {
2630     SSE_FOP(cmpeq),
2631     SSE_FOP(cmplt),
2632     SSE_FOP(cmple),
2633     SSE_FOP(cmpunord),
2634     SSE_FOP(cmpneq),
2635     SSE_FOP(cmpnlt),
2636     SSE_FOP(cmpnle),
2637     SSE_FOP(cmpord),
2638 };
2639
2640 static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
2641 {
2642     int b1, op1_offset, op2_offset, is_xmm, val, ot;
2643     int modrm, mod, rm, reg, reg_addr, offset_addr;
2644     GenOpFunc2 *sse_op2;
2645     GenOpFunc3 *sse_op3;
2646
2647     b &= 0xff;
2648     if (s->prefix & PREFIX_DATA)
2649         b1 = 1;
2650     else if (s->prefix & PREFIX_REPZ)
2651         b1 = 2;
2652     else if (s->prefix & PREFIX_REPNZ)
2653         b1 = 3;
2654     else
2655         b1 = 0;
2656     sse_op2 = sse_op_table1[b][b1];
2657     if (!sse_op2)
2658         goto illegal_op;
2659     if (b <= 0x5f || b == 0xc6 || b == 0xc2) {
2660         is_xmm = 1;
2661     } else {
2662         if (b1 == 0) {
2663             /* MMX case */
2664             is_xmm = 0;
2665         } else {
2666             is_xmm = 1;
2667         }
2668     }
2669     /* simple MMX/SSE operation */
2670     if (s->flags & HF_TS_MASK) {
2671         gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
2672         return;
2673     }
2674     if (s->flags & HF_EM_MASK) {
2675     illegal_op:
2676         gen_exception(s, EXCP06_ILLOP, pc_start - s->cs_base);
2677         return;
2678     }
2679     if (is_xmm && !(s->flags & HF_OSFXSR_MASK))
2680         goto illegal_op;
2681     if (b == 0x77) {
2682         /* emms */
2683         gen_op_emms();
2684         return;
2685     }
2686     /* prepare MMX state (XXX: optimize by storing fptt and fptags in
2687        the static cpu state) */
2688     if (!is_xmm) {
2689         gen_op_enter_mmx();
2690     }
2691
2692     modrm = ldub_code(s->pc++);
2693     reg = ((modrm >> 3) & 7);
2694     if (is_xmm)
2695         reg |= rex_r;
2696     mod = (modrm >> 6) & 3;
2697     if (sse_op2 == SSE_SPECIAL) {
2698         b |= (b1 << 8);
2699         switch(b) {
2700         case 0x0e7: /* movntq */
2701             if (mod == 3)
2702                 goto illegal_op;
2703             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2704             gen_stq_env_A0[s->mem_index >> 2](offsetof(CPUX86State,fpregs[reg].mmx));
2705             break;
2706         case 0x1e7: /* movntdq */
2707         case 0x02b: /* movntps */
2708         case 0x12b: /* movntps */
2709         case 0x3f0: /* lddqu */
2710             if (mod == 3)
2711                 goto illegal_op;
2712             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2713             gen_sto_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_regs[reg]));
2714             break;
2715         case 0x6e: /* movd mm, ea */
2716 #ifdef TARGET_X86_64
2717             if (s->dflag == 2) {
2718                 gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 0);
2719                 gen_op_movq_mm_T0_mmx(offsetof(CPUX86State,fpregs[reg].mmx));
2720             } else
2721 #endif
2722             {
2723                 gen_ldst_modrm(s, modrm, OT_LONG, OR_TMP0, 0);
2724                 gen_op_movl_mm_T0_mmx(offsetof(CPUX86State,fpregs[reg].mmx));
2725             }
2726             break;
2727         case 0x16e: /* movd xmm, ea */
2728 #ifdef TARGET_X86_64
2729             if (s->dflag == 2) {
2730                 gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 0);
2731                 gen_op_movq_mm_T0_xmm(offsetof(CPUX86State,xmm_regs[reg]));
2732             } else
2733 #endif
2734             {
2735                 gen_ldst_modrm(s, modrm, OT_LONG, OR_TMP0, 0);
2736                 gen_op_movl_mm_T0_xmm(offsetof(CPUX86State,xmm_regs[reg]));
2737             }
2738             break;
2739         case 0x6f: /* movq mm, ea */
2740             if (mod != 3) {
2741                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2742                 gen_ldq_env_A0[s->mem_index >> 2](offsetof(CPUX86State,fpregs[reg].mmx));
2743             } else {
2744                 rm = (modrm & 7);
2745                 gen_op_movq(offsetof(CPUX86State,fpregs[reg].mmx),
2746                             offsetof(CPUX86State,fpregs[rm].mmx));
2747             }
2748             break;
2749         case 0x010: /* movups */
2750         case 0x110: /* movupd */
2751         case 0x028: /* movaps */
2752         case 0x128: /* movapd */
2753         case 0x16f: /* movdqa xmm, ea */
2754         case 0x26f: /* movdqu xmm, ea */
2755             if (mod != 3) {
2756                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2757                 gen_ldo_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_regs[reg]));
2758             } else {
2759                 rm = (modrm & 7) | REX_B(s);
2760                 gen_op_movo(offsetof(CPUX86State,xmm_regs[reg]),
2761                             offsetof(CPUX86State,xmm_regs[rm]));
2762             }
2763             break;
2764         case 0x210: /* movss xmm, ea */
2765             if (mod != 3) {
2766                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2767                 gen_op_ld_T0_A0[OT_LONG + s->mem_index]();
2768                 gen_op_movl_env_T0(offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)));
2769                 gen_op_movl_T0_0();
2770                 gen_op_movl_env_T0(offsetof(CPUX86State,xmm_regs[reg].XMM_L(1)));
2771                 gen_op_movl_env_T0(offsetof(CPUX86State,xmm_regs[reg].XMM_L(2)));
2772                 gen_op_movl_env_T0(offsetof(CPUX86State,xmm_regs[reg].XMM_L(3)));
2773             } else {
2774                 rm = (modrm & 7) | REX_B(s);
2775                 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)),
2776                             offsetof(CPUX86State,xmm_regs[rm].XMM_L(0)));
2777             }
2778             break;
2779         case 0x310: /* movsd xmm, ea */
2780             if (mod != 3) {
2781                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2782                 gen_ldq_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
2783                 gen_op_movl_T0_0();
2784                 gen_op_movl_env_T0(offsetof(CPUX86State,xmm_regs[reg].XMM_L(2)));
2785                 gen_op_movl_env_T0(offsetof(CPUX86State,xmm_regs[reg].XMM_L(3)));
2786             } else {
2787                 rm = (modrm & 7) | REX_B(s);
2788                 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)),
2789                             offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)));
2790             }
2791             break;
2792         case 0x012: /* movlps */
2793         case 0x112: /* movlpd */
2794             if (mod != 3) {
2795                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2796                 gen_ldq_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
2797             } else {
2798                 /* movhlps */
2799                 rm = (modrm & 7) | REX_B(s);
2800                 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)),
2801                             offsetof(CPUX86State,xmm_regs[rm].XMM_Q(1)));
2802             }
2803             break;
2804         case 0x212: /* movsldup */
2805             if (mod != 3) {
2806                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2807                 gen_ldo_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_regs[reg]));
2808             } else {
2809                 rm = (modrm & 7) | REX_B(s);
2810                 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)),
2811                             offsetof(CPUX86State,xmm_regs[rm].XMM_L(0)));
2812                 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(2)),
2813                             offsetof(CPUX86State,xmm_regs[rm].XMM_L(2)));
2814             }
2815             gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(1)),
2816                         offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)));
2817             gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(3)),
2818                         offsetof(CPUX86State,xmm_regs[reg].XMM_L(2)));
2819             break;
2820         case 0x312: /* movddup */
2821             if (mod != 3) {
2822                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2823                 gen_ldq_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
2824             } else {
2825                 rm = (modrm & 7) | REX_B(s);
2826                 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)),
2827                             offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)));
2828             }
2829             gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)),
2830                         offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
2831             break;
2832         case 0x016: /* movhps */
2833         case 0x116: /* movhpd */
2834             if (mod != 3) {
2835                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2836                 gen_ldq_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)));
2837             } else {
2838                 /* movlhps */
2839                 rm = (modrm & 7) | REX_B(s);
2840                 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)),
2841                             offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)));
2842             }
2843             break;
2844         case 0x216: /* movshdup */
2845             if (mod != 3) {
2846                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2847                 gen_ldo_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_regs[reg]));
2848             } else {
2849                 rm = (modrm & 7) | REX_B(s);
2850                 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(1)),
2851                             offsetof(CPUX86State,xmm_regs[rm].XMM_L(1)));
2852                 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(3)),
2853                             offsetof(CPUX86State,xmm_regs[rm].XMM_L(3)));
2854             }
2855             gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)),
2856                         offsetof(CPUX86State,xmm_regs[reg].XMM_L(1)));
2857             gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(2)),
2858                         offsetof(CPUX86State,xmm_regs[reg].XMM_L(3)));
2859             break;
2860         case 0x7e: /* movd ea, mm */
2861 #ifdef TARGET_X86_64
2862             if (s->dflag == 2) {
2863                 gen_op_movq_T0_mm_mmx(offsetof(CPUX86State,fpregs[reg].mmx));
2864                 gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 1);
2865             } else
2866 #endif
2867             {
2868                 gen_op_movl_T0_mm_mmx(offsetof(CPUX86State,fpregs[reg].mmx));
2869                 gen_ldst_modrm(s, modrm, OT_LONG, OR_TMP0, 1);
2870             }
2871             break;
2872         case 0x17e: /* movd ea, xmm */
2873 #ifdef TARGET_X86_64
2874             if (s->dflag == 2) {
2875                 gen_op_movq_T0_mm_xmm(offsetof(CPUX86State,xmm_regs[reg]));
2876                 gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 1);
2877             } else
2878 #endif
2879             {
2880                 gen_op_movl_T0_mm_xmm(offsetof(CPUX86State,xmm_regs[reg]));
2881                 gen_ldst_modrm(s, modrm, OT_LONG, OR_TMP0, 1);
2882             }
2883             break;
2884         case 0x27e: /* movq xmm, ea */
2885             if (mod != 3) {
2886                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2887                 gen_ldq_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
2888             } else {
2889                 rm = (modrm & 7) | REX_B(s);
2890                 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)),
2891                             offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)));
2892             }
2893             gen_op_movq_env_0(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)));
2894             break;
2895         case 0x7f: /* movq ea, mm */
2896             if (mod != 3) {
2897                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2898                 gen_stq_env_A0[s->mem_index >> 2](offsetof(CPUX86State,fpregs[reg].mmx));
2899             } else {
2900                 rm = (modrm & 7);
2901                 gen_op_movq(offsetof(CPUX86State,fpregs[rm].mmx),
2902                             offsetof(CPUX86State,fpregs[reg].mmx));
2903             }
2904             break;
2905         case 0x011: /* movups */
2906         case 0x111: /* movupd */
2907         case 0x029: /* movaps */
2908         case 0x129: /* movapd */
2909         case 0x17f: /* movdqa ea, xmm */
2910         case 0x27f: /* movdqu ea, xmm */
2911             if (mod != 3) {
2912                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2913                 gen_sto_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_regs[reg]));
2914             } else {
2915                 rm = (modrm & 7) | REX_B(s);
2916                 gen_op_movo(offsetof(CPUX86State,xmm_regs[rm]),
2917                             offsetof(CPUX86State,xmm_regs[reg]));
2918             }
2919             break;
2920         case 0x211: /* movss ea, xmm */
2921             if (mod != 3) {
2922                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2923                 gen_op_movl_T0_env(offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)));
2924                 gen_op_st_T0_A0[OT_LONG + s->mem_index]();
2925             } else {
2926                 rm = (modrm & 7) | REX_B(s);
2927                 gen_op_movl(offsetof(CPUX86State,xmm_regs[rm].XMM_L(0)),
2928                             offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)));
2929             }
2930             break;
2931         case 0x311: /* movsd ea, xmm */
2932             if (mod != 3) {
2933                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2934                 gen_stq_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
2935             } else {
2936                 rm = (modrm & 7) | REX_B(s);
2937                 gen_op_movq(offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)),
2938                             offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
2939             }
2940             break;
2941         case 0x013: /* movlps */
2942         case 0x113: /* movlpd */
2943             if (mod != 3) {
2944                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2945                 gen_stq_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
2946             } else {
2947                 goto illegal_op;
2948             }
2949             break;
2950         case 0x017: /* movhps */
2951         case 0x117: /* movhpd */
2952             if (mod != 3) {
2953                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2954                 gen_stq_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)));
2955             } else {
2956                 goto illegal_op;
2957             }
2958             break;
2959         case 0x71: /* shift mm, im */
2960         case 0x72:
2961         case 0x73:
2962         case 0x171: /* shift xmm, im */
2963         case 0x172:
2964         case 0x173:
2965             val = ldub_code(s->pc++);
2966             if (is_xmm) {
2967                 gen_op_movl_T0_im(val);
2968                 gen_op_movl_env_T0(offsetof(CPUX86State,xmm_t0.XMM_L(0)));
2969                 gen_op_movl_T0_0();
2970                 gen_op_movl_env_T0(offsetof(CPUX86State,xmm_t0.XMM_L(1)));
2971                 op1_offset = offsetof(CPUX86State,xmm_t0);
2972             } else {
2973                 gen_op_movl_T0_im(val);
2974                 gen_op_movl_env_T0(offsetof(CPUX86State,mmx_t0.MMX_L(0)));
2975                 gen_op_movl_T0_0();
2976                 gen_op_movl_env_T0(offsetof(CPUX86State,mmx_t0.MMX_L(1)));
2977                 op1_offset = offsetof(CPUX86State,mmx_t0);
2978             }
2979             sse_op2 = sse_op_table2[((b - 1) & 3) * 8 + (((modrm >> 3)) & 7)][b1];
2980             if (!sse_op2)
2981                 goto illegal_op;
2982             if (is_xmm) {
2983                 rm = (modrm & 7) | REX_B(s);
2984                 op2_offset = offsetof(CPUX86State,xmm_regs[rm]);
2985             } else {
2986                 rm = (modrm & 7);
2987                 op2_offset = offsetof(CPUX86State,fpregs[rm].mmx);
2988             }
2989             sse_op2(op2_offset, op1_offset);
2990             break;
2991         case 0x050: /* movmskps */
2992             rm = (modrm & 7) | REX_B(s);
2993             gen_op_movmskps(offsetof(CPUX86State,xmm_regs[rm]));
2994             gen_op_mov_reg_T0[OT_LONG][reg]();
2995             break;
2996         case 0x150: /* movmskpd */
2997             rm = (modrm & 7) | REX_B(s);
2998             gen_op_movmskpd(offsetof(CPUX86State,xmm_regs[rm]));
2999             gen_op_mov_reg_T0[OT_LONG][reg]();
3000             break;
3001         case 0x02a: /* cvtpi2ps */
3002         case 0x12a: /* cvtpi2pd */
3003             gen_op_enter_mmx();
3004             if (mod != 3) {
3005                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3006                 op2_offset = offsetof(CPUX86State,mmx_t0);
3007                 gen_ldq_env_A0[s->mem_index >> 2](op2_offset);
3008             } else {
3009                 rm = (modrm & 7);
3010                 op2_offset = offsetof(CPUX86State,fpregs[rm].mmx);
3011             }
3012             op1_offset = offsetof(CPUX86State,xmm_regs[reg]);
3013             switch(b >> 8) {
3014             case 0x0:
3015                 gen_op_cvtpi2ps(op1_offset, op2_offset);
3016                 break;
3017             default:
3018             case 0x1:
3019                 gen_op_cvtpi2pd(op1_offset, op2_offset);
3020                 break;
3021             }
3022             break;
3023         case 0x22a: /* cvtsi2ss */
3024         case 0x32a: /* cvtsi2sd */
3025             ot = (s->dflag == 2) ? OT_QUAD : OT_LONG;
3026             gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
3027             op1_offset = offsetof(CPUX86State,xmm_regs[reg]);
3028             sse_op_table3[(s->dflag == 2) * 2 + ((b >> 8) - 2)](op1_offset);
3029             break;
3030         case 0x02c: /* cvttps2pi */
3031         case 0x12c: /* cvttpd2pi */
3032         case 0x02d: /* cvtps2pi */
3033         case 0x12d: /* cvtpd2pi */
3034             gen_op_enter_mmx();
3035             if (mod != 3) {
3036                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3037                 op2_offset = offsetof(CPUX86State,xmm_t0);
3038                 gen_ldo_env_A0[s->mem_index >> 2](op2_offset);
3039             } else {
3040                 rm = (modrm & 7) | REX_B(s);
3041                 op2_offset = offsetof(CPUX86State,xmm_regs[rm]);
3042             }
3043             op1_offset = offsetof(CPUX86State,fpregs[reg & 7].mmx);
3044             switch(b) {
3045             case 0x02c:
3046                 gen_op_cvttps2pi(op1_offset, op2_offset);
3047                 break;
3048             case 0x12c:
3049                 gen_op_cvttpd2pi(op1_offset, op2_offset);
3050                 break;
3051             case 0x02d:
3052                 gen_op_cvtps2pi(op1_offset, op2_offset);
3053                 break;
3054             case 0x12d:
3055                 gen_op_cvtpd2pi(op1_offset, op2_offset);
3056                 break;
3057             }
3058             break;
3059         case 0x22c: /* cvttss2si */
3060         case 0x32c: /* cvttsd2si */
3061         case 0x22d: /* cvtss2si */
3062         case 0x32d: /* cvtsd2si */
3063             ot = (s->dflag == 2) ? OT_QUAD : OT_LONG;
3064             if (mod != 3) {
3065                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3066                 if ((b >> 8) & 1) {
3067                     gen_ldq_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_t0.XMM_Q(0)));
3068                 } else {
3069                     gen_op_ld_T0_A0[OT_LONG + s->mem_index]();
3070                     gen_op_movl_env_T0(offsetof(CPUX86State,xmm_t0.XMM_L(0)));
3071                 }
3072                 op2_offset = offsetof(CPUX86State,xmm_t0);
3073             } else {
3074                 rm = (modrm & 7) | REX_B(s);
3075                 op2_offset = offsetof(CPUX86State,xmm_regs[rm]);
3076             }
3077             sse_op_table3[(s->dflag == 2) * 2 + ((b >> 8) - 2) + 4 +
3078                           (b & 1) * 4](op2_offset);
3079             gen_op_mov_reg_T0[ot][reg]();
3080             break;
3081         case 0xc4: /* pinsrw */
3082         case 0x1c4:
3083             s->rip_offset = 1;
3084             gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
3085             val = ldub_code(s->pc++);
3086             if (b1) {
3087                 val &= 7;
3088                 gen_op_pinsrw_xmm(offsetof(CPUX86State,xmm_regs[reg]), val);
3089             } else {
3090                 val &= 3;
3091                 gen_op_pinsrw_mmx(offsetof(CPUX86State,fpregs[reg].mmx), val);
3092             }
3093             break;
3094         case 0xc5: /* pextrw */
3095         case 0x1c5:
3096             if (mod != 3)
3097                 goto illegal_op;
3098             val = ldub_code(s->pc++);
3099             if (b1) {
3100                 val &= 7;
3101                 rm = (modrm & 7) | REX_B(s);
3102                 gen_op_pextrw_xmm(offsetof(CPUX86State,xmm_regs[rm]), val);
3103             } else {
3104                 val &= 3;
3105                 rm = (modrm & 7);
3106                 gen_op_pextrw_mmx(offsetof(CPUX86State,fpregs[rm].mmx), val);
3107             }
3108             reg = ((modrm >> 3) & 7) | rex_r;
3109             gen_op_mov_reg_T0[OT_LONG][reg]();
3110             break;
3111         case 0x1d6: /* movq ea, xmm */
3112             if (mod != 3) {
3113                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3114                 gen_stq_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3115             } else {
3116                 rm = (modrm & 7) | REX_B(s);
3117                 gen_op_movq(offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)),
3118                             offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3119                 gen_op_movq_env_0(offsetof(CPUX86State,xmm_regs[rm].XMM_Q(1)));
3120             }
3121             break;
3122         case 0x2d6: /* movq2dq */
3123             gen_op_enter_mmx();
3124             rm = (modrm & 7);
3125             gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)),
3126                         offsetof(CPUX86State,fpregs[rm].mmx));
3127             gen_op_movq_env_0(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)));
3128             break;
3129         case 0x3d6: /* movdq2q */
3130             gen_op_enter_mmx();
3131             rm = (modrm & 7) | REX_B(s);
3132             gen_op_movq(offsetof(CPUX86State,fpregs[reg & 7].mmx),
3133                         offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)));
3134             break;
3135         case 0xd7: /* pmovmskb */
3136         case 0x1d7:
3137             if (mod != 3)
3138                 goto illegal_op;
3139             if (b1) {
3140                 rm = (modrm & 7) | REX_B(s);
3141                 gen_op_pmovmskb_xmm(offsetof(CPUX86State,xmm_regs[rm]));
3142             } else {
3143                 rm = (modrm & 7);
3144                 gen_op_pmovmskb_mmx(offsetof(CPUX86State,fpregs[rm].mmx));
3145             }
3146             reg = ((modrm >> 3) & 7) | rex_r;
3147             gen_op_mov_reg_T0[OT_LONG][reg]();
3148             break;
3149         default:
3150             goto illegal_op;
3151         }
3152     } else {
3153         /* generic MMX or SSE operation */
3154         switch(b) {
3155         case 0xf7:
3156             /* maskmov : we must prepare A0 */
3157             if (mod != 3)
3158                 goto illegal_op;
3159 #ifdef TARGET_X86_64
3160             if (s->aflag == 2) {
3161                 gen_op_movq_A0_reg[R_EDI]();
3162             } else
3163 #endif
3164             {
3165                 gen_op_movl_A0_reg[R_EDI]();
3166                 if (s->aflag == 0)
3167                     gen_op_andl_A0_ffff();
3168             }
3169             gen_add_A0_ds_seg(s);
3170             break;
3171         case 0x70: /* pshufx insn */
3172         case 0xc6: /* pshufx insn */
3173         case 0xc2: /* compare insns */
3174             s->rip_offset = 1;
3175             break;
3176         default:
3177             break;
3178         }
3179         if (is_xmm) {
3180             op1_offset = offsetof(CPUX86State,xmm_regs[reg]);
3181             if (mod != 3) {
3182                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3183                 op2_offset = offsetof(CPUX86State,xmm_t0);
3184                 if (b1 >= 2 && ((b >= 0x50 && b <= 0x5f && b != 0x5b) ||
3185                                 b == 0xc2)) {
3186                     /* specific case for SSE single instructions */
3187                     if (b1 == 2) {
3188                         /* 32 bit access */
3189                         gen_op_ld_T0_A0[OT_LONG + s->mem_index]();
3190                         gen_op_movl_env_T0(offsetof(CPUX86State,xmm_t0.XMM_L(0)));
3191                     } else {
3192                         /* 64 bit access */
3193                         gen_ldq_env_A0[s->mem_index >> 2](offsetof(CPUX86State,xmm_t0.XMM_D(0)));
3194                     }
3195                 } else {
3196                     gen_ldo_env_A0[s->mem_index >> 2](op2_offset);
3197                 }
3198             } else {
3199                 rm = (modrm & 7) | REX_B(s);
3200                 op2_offset = offsetof(CPUX86State,xmm_regs[rm]);
3201             }
3202         } else {
3203             op1_offset = offsetof(CPUX86State,fpregs[reg].mmx);
3204             if (mod != 3) {
3205                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3206                 op2_offset = offsetof(CPUX86State,mmx_t0);
3207                 gen_ldq_env_A0[s->mem_index >> 2](op2_offset);
3208             } else {
3209                 rm = (modrm & 7);
3210                 op2_offset = offsetof(CPUX86State,fpregs[rm].mmx);
3211             }
3212         }
3213         switch(b) {
3214         case 0x70: /* pshufx insn */
3215         case 0xc6: /* pshufx insn */
3216             val = ldub_code(s->pc++);
3217             sse_op3 = (GenOpFunc3 *)sse_op2;
3218             sse_op3(op1_offset, op2_offset, val);
3219             break;
3220         case 0xc2:
3221             /* compare insns */
3222             val = ldub_code(s->pc++);
3223             if (val >= 8)
3224                 goto illegal_op;
3225             sse_op2 = sse_op_table4[val][b1];
3226             sse_op2(op1_offset, op2_offset);
3227             break;
3228         default:
3229             sse_op2(op1_offset, op2_offset);
3230             break;
3231         }
3232         if (b == 0x2e || b == 0x2f) {
3233             s->cc_op = CC_OP_EFLAGS;
3234         }
3235     }
3236 }
3237
3238
3239 /* convert one instruction. s->is_jmp is set if the translation must
3240    be stopped. Return the next pc value */
3241 static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
3242 {
3243     int b, prefixes, aflag, dflag;
3244     int shift, ot;
3245     int modrm, reg, rm, mod, reg_addr, op, opreg, offset_addr, val;
3246     target_ulong next_eip, tval;
3247     int rex_w, rex_r;
3248
3249     s->pc = pc_start;
3250     prefixes = 0;
3251     aflag = s->code32;
3252     dflag = s->code32;
3253     s->override = -1;
3254     rex_w = -1;
3255     rex_r = 0;
3256 #ifdef TARGET_X86_64
3257     s->rex_x = 0;
3258     s->rex_b = 0;
3259     x86_64_hregs = 0;
3260 #endif
3261     s->rip_offset = 0; /* for relative ip address */
3262  next_byte:
3263     b = ldub_code(s->pc);
3264     s->pc++;
3265     /* check prefixes */
3266 #ifdef TARGET_X86_64
3267     if (CODE64(s)) {
3268         switch (b) {
3269         case 0xf3:
3270             prefixes |= PREFIX_REPZ;
3271             goto next_byte;
3272         case 0xf2:
3273             prefixes |= PREFIX_REPNZ;
3274             goto next_byte;
3275         case 0xf0:
3276             prefixes |= PREFIX_LOCK;
3277             goto next_byte;
3278         case 0x2e:
3279             s->override = R_CS;
3280             goto next_byte;
3281         case 0x36:
3282             s->override = R_SS;
3283             goto next_byte;
3284         case 0x3e:
3285             s->override = R_DS;
3286             goto next_byte;
3287         case 0x26:
3288             s->override = R_ES;
3289             goto next_byte;
3290         case 0x64:
3291             s->override = R_FS;
3292             goto next_byte;
3293         case 0x65:
3294             s->override = R_GS;
3295             goto next_byte;
3296         case 0x66:
3297             prefixes |= PREFIX_DATA;
3298             goto next_byte;
3299         case 0x67:
3300             prefixes |= PREFIX_ADR;
3301             goto next_byte;
3302         case 0x40 ... 0x4f:
3303             /* REX prefix */
3304             rex_w = (b >> 3) & 1;
3305             rex_r = (b & 0x4) << 1;
3306             s->rex_x = (b & 0x2) << 2;
3307             REX_B(s) = (b & 0x1) << 3;
3308             x86_64_hregs = 1; /* select uniform byte register addressing */
3309             goto next_byte;
3310         }
3311         if (rex_w == 1) {
3312             /* 0x66 is ignored if rex.w is set */
3313             dflag = 2;
3314         } else {
3315             if (prefixes & PREFIX_DATA)
3316                 dflag ^= 1;
3317         }
3318         if (!(prefixes & PREFIX_ADR))
3319             aflag = 2;
3320     } else
3321 #endif
3322     {
3323         switch (b) {
3324         case 0xf3:
3325             prefixes |= PREFIX_REPZ;
3326             goto next_byte;
3327         case 0xf2:
3328             prefixes |= PREFIX_REPNZ;
3329             goto next_byte;
3330         case 0xf0:
3331             prefixes |= PREFIX_LOCK;
3332             goto next_byte;
3333         case 0x2e:
3334             s->override = R_CS;
3335             goto next_byte;
3336         case 0x36:
3337             s->override = R_SS;
3338             goto next_byte;
3339         case 0x3e:
3340             s->override = R_DS;
3341             goto next_byte;
3342         case 0x26:
3343             s->override = R_ES;
3344             goto next_byte;
3345         case 0x64:
3346             s->override = R_FS;
3347             goto next_byte;
3348         case 0x65:
3349             s->override = R_GS;
3350             goto next_byte;
3351         case 0x66:
3352             prefixes |= PREFIX_DATA;
3353             goto next_byte;
3354         case 0x67:
3355             prefixes |= PREFIX_ADR;
3356             goto next_byte;
3357         }
3358         if (prefixes & PREFIX_DATA)
3359             dflag ^= 1;
3360         if (prefixes & PREFIX_ADR)
3361             aflag ^= 1;
3362     }
3363
3364     s->prefix = prefixes;
3365     s->aflag = aflag;
3366     s->dflag = dflag;
3367
3368     /* lock generation */
3369     if (prefixes & PREFIX_LOCK)
3370         gen_op_lock();
3371
3372     /* now check op code */
3373  reswitch:
3374     switch(b) {
3375     case 0x0f:
3376         /**************************/
3377         /* extended op code */
3378         b = ldub_code(s->pc++) | 0x100;
3379         goto reswitch;
3380
3381         /**************************/
3382         /* arith & logic */
3383     case 0x00 ... 0x05:
3384     case 0x08 ... 0x0d:
3385     case 0x10 ... 0x15:
3386     case 0x18 ... 0x1d:
3387     case 0x20 ... 0x25:
3388     case 0x28 ... 0x2d:
3389     case 0x30 ... 0x35:
3390     case 0x38 ... 0x3d:
3391         {
3392             int op, f, val;
3393             op = (b >> 3) & 7;
3394             f = (b >> 1) & 3;
3395
3396             if ((b & 1) == 0)
3397                 ot = OT_BYTE;
3398             else
3399                 ot = dflag + OT_WORD;
3400
3401             switch(f) {
3402             case 0: /* OP Ev, Gv */
3403                 modrm = ldub_code(s->pc++);
3404                 reg = ((modrm >> 3) & 7) | rex_r;
3405                 mod = (modrm >> 6) & 3;
3406                 rm = (modrm & 7) | REX_B(s);
3407                 if (mod != 3) {
3408                     gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3409                     opreg = OR_TMP0;
3410                 } else if (op == OP_XORL && rm == reg) {
3411                 xor_zero:
3412                     /* xor reg, reg optimisation */
3413                     gen_op_movl_T0_0();
3414                     s->cc_op = CC_OP_LOGICB + ot;
3415                     gen_op_mov_reg_T0[ot][reg]();
3416                     gen_op_update1_cc();
3417                     break;
3418                 } else {
3419                     opreg = rm;
3420                 }
3421                 gen_op_mov_TN_reg[ot][1][reg]();
3422                 gen_op(s, op, ot, opreg);
3423                 break;
3424             case 1: /* OP Gv, Ev */
3425                 modrm = ldub_code(s->pc++);
3426                 mod = (modrm >> 6) & 3;
3427                 reg = ((modrm >> 3) & 7) | rex_r;
3428                 rm = (modrm & 7) | REX_B(s);
3429                 if (mod != 3) {
3430                     gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3431                     gen_op_ld_T1_A0[ot + s->mem_index]();
3432                 } else if (op == OP_XORL && rm == reg) {
3433                     goto xor_zero;
3434                 } else {
3435                     gen_op_mov_TN_reg[ot][1][rm]();
3436                 }
3437                 gen_op(s, op, ot, reg);
3438                 break;
3439             case 2: /* OP A, Iv */
3440                 val = insn_get(s, ot);
3441                 gen_op_movl_T1_im(val);
3442                 gen_op(s, op, ot, OR_EAX);
3443                 break;
3444             }
3445         }
3446         break;
3447
3448     case 0x80: /* GRP1 */
3449     case 0x81:
3450     case 0x82:
3451     case 0x83:
3452         {
3453             int val;
3454
3455             if ((b & 1) == 0)
3456                 ot = OT_BYTE;
3457             else
3458                 ot = dflag + OT_WORD;
3459
3460             modrm = ldub_code(s->pc++);
3461             mod = (modrm >> 6) & 3;
3462             rm = (modrm & 7) | REX_B(s);
3463             op = (modrm >> 3) & 7;
3464
3465             if (mod != 3) {
3466                 if (b == 0x83)
3467                     s->rip_offset = 1;
3468                 else
3469                     s->rip_offset = insn_const_size(ot);
3470                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3471                 opreg = OR_TMP0;
3472             } else {
3473                 opreg = rm;
3474             }
3475
3476             switch(b) {
3477             default:
3478             case 0x80:
3479             case 0x81:
3480             case 0x82:
3481                 val = insn_get(s, ot);
3482                 break;
3483             case 0x83:
3484                 val = (int8_t)insn_get(s, OT_BYTE);
3485                 break;
3486             }
3487             gen_op_movl_T1_im(val);
3488             gen_op(s, op, ot, opreg);
3489         }
3490         break;
3491
3492         /**************************/
3493         /* inc, dec, and other misc arith */
3494     case 0x40 ... 0x47: /* inc Gv */
3495         ot = dflag ? OT_LONG : OT_WORD;
3496         gen_inc(s, ot, OR_EAX + (b & 7), 1);
3497         break;
3498     case 0x48 ... 0x4f: /* dec Gv */
3499         ot = dflag ? OT_LONG : OT_WORD;
3500         gen_inc(s, ot, OR_EAX + (b & 7), -1);
3501         break;
3502     case 0xf6: /* GRP3 */
3503     case 0xf7:
3504         if ((b & 1) == 0)
3505             ot = OT_BYTE;
3506         else
3507             ot = dflag + OT_WORD;
3508
3509         modrm = ldub_code(s->pc++);
3510         mod = (modrm >> 6) & 3;
3511         rm = (modrm & 7) | REX_B(s);
3512         op = (modrm >> 3) & 7;
3513         if (mod != 3) {
3514             if (op == 0)
3515                 s->rip_offset = insn_const_size(ot);
3516             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3517             gen_op_ld_T0_A0[ot + s->mem_index]();
3518         } else {
3519             gen_op_mov_TN_reg[ot][0][rm]();
3520         }
3521
3522         switch(op) {
3523         case 0: /* test */
3524             val = insn_get(s, ot);
3525             gen_op_movl_T1_im(val);
3526             gen_op_testl_T0_T1_cc();
3527             s->cc_op = CC_OP_LOGICB + ot;
3528             break;
3529         case 2: /* not */
3530             gen_op_notl_T0();
3531             if (mod != 3) {
3532                 gen_op_st_T0_A0[ot + s->mem_index]();
3533             } else {
3534                 gen_op_mov_reg_T0[ot][rm]();
3535             }
3536             break;
3537         case 3: /* neg */
3538             gen_op_negl_T0();
3539             if (mod != 3) {
3540                 gen_op_st_T0_A0[ot + s->mem_index]();
3541             } else {
3542                 gen_op_mov_reg_T0[ot][rm]();
3543             }
3544             gen_op_update_neg_cc();
3545             s->cc_op = CC_OP_SUBB + ot;
3546             break;
3547         case 4: /* mul */
3548             switch(ot) {
3549             case OT_BYTE:
3550                 gen_op_mulb_AL_T0();
3551                 s->cc_op = CC_OP_MULB;
3552                 break;
3553             case OT_WORD:
3554                 gen_op_mulw_AX_T0();
3555                 s->cc_op = CC_OP_MULW;
3556                 break;
3557             default:
3558             case OT_LONG:
3559                 gen_op_mull_EAX_T0();
3560                 s->cc_op = CC_OP_MULL;
3561                 break;
3562 #ifdef TARGET_X86_64
3563             case OT_QUAD:
3564                 gen_op_mulq_EAX_T0();
3565                 s->cc_op = CC_OP_MULQ;
3566                 break;
3567 #endif
3568             }
3569             break;
3570         case 5: /* imul */
3571             switch(ot) {
3572             case OT_BYTE:
3573                 gen_op_imulb_AL_T0();
3574                 s->cc_op = CC_OP_MULB;
3575                 break;
3576             case OT_WORD:
3577                 gen_op_imulw_AX_T0();
3578                 s->cc_op = CC_OP_MULW;
3579                 break;
3580             default:
3581             case OT_LONG:
3582                 gen_op_imull_EAX_T0();
3583                 s->cc_op = CC_OP_MULL;
3584                 break;
3585 #ifdef TARGET_X86_64
3586             case OT_QUAD:
3587                 gen_op_imulq_EAX_T0();
3588                 s->cc_op = CC_OP_MULQ;
3589                 break;
3590 #endif
3591             }
3592             break;
3593         case 6: /* div */
3594             switch(ot) {
3595             case OT_BYTE:
3596                 gen_jmp_im(pc_start - s->cs_base);
3597                 gen_op_divb_AL_T0();
3598                 break;
3599             case OT_WORD:
3600                 gen_jmp_im(pc_start - s->cs_base);
3601                 gen_op_divw_AX_T0();
3602                 break;
3603             default:
3604             case OT_LONG:
3605                 gen_jmp_im(pc_start - s->cs_base);
3606                 gen_op_divl_EAX_T0();
3607                 break;
3608 #ifdef TARGET_X86_64
3609             case OT_QUAD:
3610                 gen_jmp_im(pc_start - s->cs_base);
3611                 gen_op_divq_EAX_T0();
3612                 break;
3613 #endif
3614             }
3615             break;
3616         case 7: /* idiv */
3617             switch(ot) {
3618             case OT_BYTE:
3619                 gen_jmp_im(pc_start - s->cs_base);
3620                 gen_op_idivb_AL_T0();
3621                 break;
3622             case OT_WORD:
3623                 gen_jmp_im(pc_start - s->cs_base);
3624                 gen_op_idivw_AX_T0();
3625                 break;
3626             default:
3627             case OT_LONG:
3628                 gen_jmp_im(pc_start - s->cs_base);
3629                 gen_op_idivl_EAX_T0();
3630                 break;
3631 #ifdef TARGET_X86_64
3632             case OT_QUAD:
3633                 gen_jmp_im(pc_start - s->cs_base);
3634                 gen_op_idivq_EAX_T0();
3635                 break;
3636 #endif
3637             }
3638             break;
3639         default:
3640             goto illegal_op;
3641         }
3642         break;
3643
3644     case 0xfe: /* GRP4 */
3645     case 0xff: /* GRP5 */
3646         if ((b & 1) == 0)
3647             ot = OT_BYTE;
3648         else
3649             ot = dflag + OT_WORD;
3650
3651         modrm = ldub_code(s->pc++);
3652         mod = (modrm >> 6) & 3;
3653         rm = (modrm & 7) | REX_B(s);
3654         op = (modrm >> 3) & 7;
3655         if (op >= 2 && b == 0xfe) {
3656             goto illegal_op;
3657         }
3658         if (CODE64(s)) {
3659             if (op == 2 || op == 4) {
3660                 /* operand size for jumps is 64 bit */
3661                 ot = OT_QUAD;
3662             } else if (op == 3 || op == 5) {
3663                 /* for call calls, the operand is 16 or 32 bit, even
3664                    in long mode */
3665                 ot = dflag ? OT_LONG : OT_WORD;
3666             } else if (op == 6) {
3667                 /* default push size is 64 bit */
3668                 ot = dflag ? OT_QUAD : OT_WORD;
3669             }
3670         }
3671         if (mod != 3) {
3672             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3673             if (op >= 2 && op != 3 && op != 5)
3674                 gen_op_ld_T0_A0[ot + s->mem_index]();
3675         } else {
3676             gen_op_mov_TN_reg[ot][0][rm]();
3677         }
3678
3679         switch(op) {
3680         case 0: /* inc Ev */
3681             if (mod != 3)
3682                 opreg = OR_TMP0;
3683             else
3684                 opreg = rm;
3685             gen_inc(s, ot, opreg, 1);
3686             break;
3687         case 1: /* dec Ev */
3688             if (mod != 3)
3689                 opreg = OR_TMP0;
3690             else
3691                 opreg = rm;
3692             gen_inc(s, ot, opreg, -1);
3693             break;
3694         case 2: /* call Ev */
3695             /* XXX: optimize if memory (no 'and' is necessary) */
3696             if (s->dflag == 0)
3697                 gen_op_andl_T0_ffff();
3698             next_eip = s->pc - s->cs_base;
3699             gen_movtl_T1_im(next_eip);
3700             gen_push_T1(s);
3701             gen_op_jmp_T0();
3702             gen_eob(s);
3703             break;
3704         case 3: /* lcall Ev */
3705             gen_op_ld_T1_A0[ot + s->mem_index]();
3706             gen_add_A0_im(s, 1 << (ot - OT_WORD + 1));
3707             gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
3708         do_lcall:
3709             if (s->pe && !s->vm86) {
3710                 if (s->cc_op != CC_OP_DYNAMIC)
3711                     gen_op_set_cc_op(s->cc_op);
3712                 gen_jmp_im(pc_start - s->cs_base);
3713                 gen_op_lcall_protected_T0_T1(dflag, s->pc - pc_start);
3714             } else {
3715                 gen_op_lcall_real_T0_T1(dflag, s->pc - s->cs_base);
3716             }
3717             gen_eob(s);
3718             break;
3719         case 4: /* jmp Ev */
3720             if (s->dflag == 0)
3721                 gen_op_andl_T0_ffff();
3722             gen_op_jmp_T0();
3723             gen_eob(s);
3724             break;
3725         case 5: /* ljmp Ev */
3726             gen_op_ld_T1_A0[ot + s->mem_index]();
3727             gen_add_A0_im(s, 1 << (ot - OT_WORD + 1));
3728             gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
3729         do_ljmp:
3730             if (s->pe && !s->vm86) {
3731                 if (s->cc_op != CC_OP_DYNAMIC)
3732                     gen_op_set_cc_op(s->cc_op);
3733                 gen_jmp_im(pc_start - s->cs_base);
3734                 gen_op_ljmp_protected_T0_T1(s->pc - pc_start);
3735             } else {
3736                 gen_op_movl_seg_T0_vm(offsetof(CPUX86State,segs[R_CS]));
3737                 gen_op_movl_T0_T1();
3738                 gen_op_jmp_T0();
3739             }
3740             gen_eob(s);
3741             break;
3742         case 6: /* push Ev */
3743             gen_push_T0(s);
3744             break;
3745         default:
3746             goto illegal_op;
3747         }
3748         break;
3749
3750     case 0x84: /* test Ev, Gv */
3751     case 0x85:
3752         if ((b & 1) == 0)
3753             ot = OT_BYTE;
3754         else
3755             ot = dflag + OT_WORD;
3756
3757         modrm = ldub_code(s->pc++);
3758         mod = (modrm >> 6) & 3;
3759         rm = (modrm & 7) | REX_B(s);
3760         reg = ((modrm >> 3) & 7) | rex_r;
3761
3762         gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
3763         gen_op_mov_TN_reg[ot][1][reg]();
3764         gen_op_testl_T0_T1_cc();
3765         s->cc_op = CC_OP_LOGICB + ot;
3766         break;
3767
3768     case 0xa8: /* test eAX, Iv */
3769     case 0xa9:
3770         if ((b & 1) == 0)
3771             ot = OT_BYTE;
3772         else
3773             ot = dflag + OT_WORD;
3774         val = insn_get(s, ot);
3775
3776         gen_op_mov_TN_reg[ot][0][OR_EAX]();
3777         gen_op_movl_T1_im(val);
3778         gen_op_testl_T0_T1_cc();
3779         s->cc_op = CC_OP_LOGICB + ot;
3780         break;
3781
3782     case 0x98: /* CWDE/CBW */
3783 #ifdef TARGET_X86_64
3784         if (dflag == 2) {
3785             gen_op_movslq_RAX_EAX();
3786         } else
3787 #endif
3788         if (dflag == 1)
3789             gen_op_movswl_EAX_AX();
3790         else
3791             gen_op_movsbw_AX_AL();
3792         break;
3793     case 0x99: /* CDQ/CWD */
3794 #ifdef TARGET_X86_64
3795         if (dflag == 2) {
3796             gen_op_movsqo_RDX_RAX();
3797         } else
3798 #endif
3799         if (dflag == 1)
3800             gen_op_movslq_EDX_EAX();
3801         else
3802             gen_op_movswl_DX_AX();
3803         break;
3804     case 0x1af: /* imul Gv, Ev */
3805     case 0x69: /* imul Gv, Ev, I */
3806     case 0x6b:
3807         ot = dflag + OT_WORD;
3808         modrm = ldub_code(s->pc++);
3809         reg = ((modrm >> 3) & 7) | rex_r;
3810         if (b == 0x69)
3811             s->rip_offset = insn_const_size(ot);
3812         else if (b == 0x6b)
3813             s->rip_offset = 1;
3814         gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
3815         if (b == 0x69) {
3816             val = insn_get(s, ot);
3817             gen_op_movl_T1_im(val);
3818         } else if (b == 0x6b) {
3819             val = (int8_t)insn_get(s, OT_BYTE);
3820             gen_op_movl_T1_im(val);
3821         } else {
3822             gen_op_mov_TN_reg[ot][1][reg]();
3823         }
3824
3825 #ifdef TARGET_X86_64
3826         if (ot == OT_QUAD) {
3827             gen_op_imulq_T0_T1();
3828         } else
3829 #endif
3830         if (ot == OT_LONG) {
3831             gen_op_imull_T0_T1();
3832         } else {
3833             gen_op_imulw_T0_T1();
3834         }
3835         gen_op_mov_reg_T0[ot][reg]();
3836         s->cc_op = CC_OP_MULB + ot;
3837         break;
3838     case 0x1c0:
3839     case 0x1c1: /* xadd Ev, Gv */
3840         if ((b & 1) == 0)
3841             ot = OT_BYTE;
3842         else
3843             ot = dflag + OT_WORD;
3844         modrm = ldub_code(s->pc++);
3845         reg = ((modrm >> 3) & 7) | rex_r;
3846         mod = (modrm >> 6) & 3;
3847         if (mod == 3) {
3848             rm = (modrm & 7) | REX_B(s);
3849             gen_op_mov_TN_reg[ot][0][reg]();
3850             gen_op_mov_TN_reg[ot][1][rm]();
3851             gen_op_addl_T0_T1();
3852             gen_op_mov_reg_T1[ot][reg]();
3853             gen_op_mov_reg_T0[ot][rm]();
3854         } else {
3855             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3856             gen_op_mov_TN_reg[ot][0][reg]();
3857             gen_op_ld_T1_A0[ot + s->mem_index]();
3858             gen_op_addl_T0_T1();
3859             gen_op_st_T0_A0[ot + s->mem_index]();
3860             gen_op_mov_reg_T1[ot][reg]();
3861         }
3862         gen_op_update2_cc();
3863         s->cc_op = CC_OP_ADDB + ot;
3864         break;
3865     case 0x1b0:
3866     case 0x1b1: /* cmpxchg Ev, Gv */
3867         if ((b & 1) == 0)
3868             ot = OT_BYTE;
3869         else
3870             ot = dflag + OT_WORD;
3871         modrm = ldub_code(s->pc++);
3872         reg = ((modrm >> 3) & 7) | rex_r;
3873         mod = (modrm >> 6) & 3;
3874         gen_op_mov_TN_reg[ot][1][reg]();
3875         if (mod == 3) {
3876             rm = (modrm & 7) | REX_B(s);
3877             gen_op_mov_TN_reg[ot][0][rm]();
3878             gen_op_cmpxchg_T0_T1_EAX_cc[ot]();
3879             gen_op_mov_reg_T0[ot][rm]();
3880         } else {
3881             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3882             gen_op_ld_T0_A0[ot + s->mem_index]();
3883             gen_op_cmpxchg_mem_T0_T1_EAX_cc[ot + s->mem_index]();
3884         }
3885         s->cc_op = CC_OP_SUBB + ot;
3886         break;
3887     case 0x1c7: /* cmpxchg8b */
3888         modrm = ldub_code(s->pc++);
3889         mod = (modrm >> 6) & 3;
3890         if (mod == 3)
3891             goto illegal_op;
3892         gen_jmp_im(pc_start - s->cs_base);
3893         if (s->cc_op != CC_OP_DYNAMIC)
3894             gen_op_set_cc_op(s->cc_op);
3895         gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3896         gen_op_cmpxchg8b();
3897         s->cc_op = CC_OP_EFLAGS;
3898         break;
3899
3900         /**************************/
3901         /* push/pop */
3902     case 0x50 ... 0x57: /* push */
3903         gen_op_mov_TN_reg[OT_LONG][0][(b & 7) | REX_B(s)]();
3904         gen_push_T0(s);
3905         break;
3906     case 0x58 ... 0x5f: /* pop */
3907         if (CODE64(s)) {
3908             ot = dflag ? OT_QUAD : OT_WORD;
3909         } else {
3910             ot = dflag + OT_WORD;
3911         }
3912         gen_pop_T0(s);
3913         /* NOTE: order is important for pop %sp */
3914         gen_pop_update(s);
3915         gen_op_mov_reg_T0[ot][(b & 7) | REX_B(s)]();
3916         break;
3917     case 0x60: /* pusha */
3918         if (CODE64(s))
3919             goto illegal_op;
3920         gen_pusha(s);
3921         break;
3922     case 0x61: /* popa */
3923         if (CODE64(s))
3924             goto illegal_op;
3925         gen_popa(s);
3926         break;
3927     case 0x68: /* push Iv */
3928     case 0x6a:
3929         if (CODE64(s)) {
3930             ot = dflag ? OT_QUAD : OT_WORD;
3931         } else {
3932             ot = dflag + OT_WORD;
3933         }
3934         if (b == 0x68)
3935             val = insn_get(s, ot);
3936         else
3937             val = (int8_t)insn_get(s, OT_BYTE);
3938         gen_op_movl_T0_im(val);
3939         gen_push_T0(s);
3940         break;
3941     case 0x8f: /* pop Ev */
3942         if (CODE64(s)) {
3943             ot = dflag ? OT_QUAD : OT_WORD;
3944         } else {
3945             ot = dflag + OT_WORD;
3946         }
3947         modrm = ldub_code(s->pc++);
3948         mod = (modrm >> 6) & 3;
3949         gen_pop_T0(s);
3950         if (mod == 3) {
3951             /* NOTE: order is important for pop %sp */
3952             gen_pop_update(s);
3953             rm = (modrm & 7) | REX_B(s);
3954             gen_op_mov_reg_T0[ot][rm]();
3955         } else {
3956             /* NOTE: order is important too for MMU exceptions */
3957             s->popl_esp_hack = 1 << ot;
3958             gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
3959             s->popl_esp_hack = 0;
3960             gen_pop_update(s);
3961         }
3962         break;
3963     case 0xc8: /* enter */
3964         {
3965             int level;
3966             val = lduw_code(s->pc);
3967             s->pc += 2;
3968             level = ldub_code(s->pc++);
3969             gen_enter(s, val, level);
3970         }
3971         break;
3972     case 0xc9: /* leave */
3973         /* XXX: exception not precise (ESP is updated before potential exception) */
3974         if (CODE64(s)) {
3975             gen_op_mov_TN_reg[OT_QUAD][0][R_EBP]();
3976             gen_op_mov_reg_T0[OT_QUAD][R_ESP]();
3977         } else if (s->ss32) {
3978             gen_op_mov_TN_reg[OT_LONG][0][R_EBP]();
3979             gen_op_mov_reg_T0[OT_LONG][R_ESP]();
3980         } else {
3981             gen_op_mov_TN_reg[OT_WORD][0][R_EBP]();
3982             gen_op_mov_reg_T0[OT_WORD][R_ESP]();
3983         }
3984         gen_pop_T0(s);
3985         if (CODE64(s)) {
3986             ot = dflag ? OT_QUAD : OT_WORD;
3987         } else {
3988             ot = dflag + OT_WORD;
3989         }
3990         gen_op_mov_reg_T0[ot][R_EBP]();
3991         gen_pop_update(s);
3992         break;
3993     case 0x06: /* push es */
3994     case 0x0e: /* push cs */
3995     case 0x16: /* push ss */
3996     case 0x1e: /* push ds */
3997         if (CODE64(s))
3998             goto illegal_op;
3999         gen_op_movl_T0_seg(b >> 3);
4000         gen_push_T0(s);
4001         break;
4002     case 0x1a0: /* push fs */
4003     case 0x1a8: /* push gs */
4004         gen_op_movl_T0_seg((b >> 3) & 7);
4005         gen_push_T0(s);
4006         break;
4007     case 0x07: /* pop es */
4008     case 0x17: /* pop ss */
4009     case 0x1f: /* pop ds */
4010         if (CODE64(s))
4011             goto illegal_op;
4012         reg = b >> 3;
4013         gen_pop_T0(s);
4014         gen_movl_seg_T0(s, reg, pc_start - s->cs_base);
4015         gen_pop_update(s);
4016         if (reg == R_SS) {
4017             /* if reg == SS, inhibit interrupts/trace. */
4018             /* If several instructions disable interrupts, only the
4019                _first_ does it */
4020             if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
4021                 gen_op_set_inhibit_irq();
4022             s->tf = 0;
4023         }
4024         if (s->is_jmp) {
4025             gen_jmp_im(s->pc - s->cs_base);
4026             gen_eob(s);
4027         }
4028         break;
4029     case 0x1a1: /* pop fs */
4030     case 0x1a9: /* pop gs */
4031         gen_pop_T0(s);
4032         gen_movl_seg_T0(s, (b >> 3) & 7, pc_start - s->cs_base);
4033         gen_pop_update(s);
4034         if (s->is_jmp) {
4035             gen_jmp_im(s->pc - s->cs_base);
4036             gen_eob(s);
4037         }
4038         break;
4039
4040         /**************************/
4041         /* mov */
4042     case 0x88:
4043     case 0x89: /* mov Gv, Ev */
4044         if ((b & 1) == 0)
4045             ot = OT_BYTE;
4046         else
4047             ot = dflag + OT_WORD;
4048         modrm = ldub_code(s->pc++);
4049         reg = ((modrm >> 3) & 7) | rex_r;
4050
4051         /* generate a generic store */
4052         gen_ldst_modrm(s, modrm, ot, reg, 1);
4053         break;
4054     case 0xc6:
4055     case 0xc7: /* mov Ev, Iv */
4056         if ((b & 1) == 0)
4057             ot = OT_BYTE;
4058         else
4059             ot = dflag + OT_WORD;
4060         modrm = ldub_code(s->pc++);
4061         mod = (modrm >> 6) & 3;
4062         if (mod != 3) {
4063             s->rip_offset = insn_const_size(ot);
4064             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4065         }
4066         val = insn_get(s, ot);
4067         gen_op_movl_T0_im(val);
4068         if (mod != 3)
4069             gen_op_st_T0_A0[ot + s->mem_index]();
4070         else
4071             gen_op_mov_reg_T0[ot][(modrm & 7) | REX_B(s)]();
4072         break;
4073     case 0x8a:
4074     case 0x8b: /* mov Ev, Gv */
4075         if ((b & 1) == 0)
4076             ot = OT_BYTE;
4077         else
4078             ot = OT_WORD + dflag;
4079         modrm = ldub_code(s->pc++);
4080         reg = ((modrm >> 3) & 7) | rex_r;
4081
4082         gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
4083         gen_op_mov_reg_T0[ot][reg]();
4084         break;
4085     case 0x8e: /* mov seg, Gv */
4086         modrm = ldub_code(s->pc++);
4087         reg = (modrm >> 3) & 7;
4088         if (reg >= 6 || reg == R_CS)
4089             goto illegal_op;
4090         gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
4091         gen_movl_seg_T0(s, reg, pc_start - s->cs_base);
4092         if (reg == R_SS) {
4093             /* if reg == SS, inhibit interrupts/trace */
4094             /* If several instructions disable interrupts, only the
4095                _first_ does it */
4096             if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
4097                 gen_op_set_inhibit_irq();
4098             s->tf = 0;
4099         }
4100         if (s->is_jmp) {
4101             gen_jmp_im(s->pc - s->cs_base);
4102             gen_eob(s);
4103         }
4104         break;
4105     case 0x8c: /* mov Gv, seg */
4106         modrm = ldub_code(s->pc++);
4107         reg = (modrm >> 3) & 7;
4108         mod = (modrm >> 6) & 3;
4109         if (reg >= 6)
4110             goto illegal_op;
4111         gen_op_movl_T0_seg(reg);
4112         if (mod == 3)
4113             ot = OT_WORD + dflag;
4114         else
4115             ot = OT_WORD;
4116         gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
4117         break;
4118
4119     case 0x1b6: /* movzbS Gv, Eb */
4120     case 0x1b7: /* movzwS Gv, Eb */
4121     case 0x1be: /* movsbS Gv, Eb */
4122     case 0x1bf: /* movswS Gv, Eb */
4123         {
4124             int d_ot;
4125             /* d_ot is the size of destination */
4126             d_ot = dflag + OT_WORD;
4127             /* ot is the size of source */
4128             ot = (b & 1) + OT_BYTE;
4129             modrm = ldub_code(s->pc++);
4130             reg = ((modrm >> 3) & 7) | rex_r;
4131             mod = (modrm >> 6) & 3;
4132             rm = (modrm & 7) | REX_B(s);
4133
4134             if (mod == 3) {
4135                 gen_op_mov_TN_reg[ot][0][rm]();
4136                 switch(ot | (b & 8)) {
4137                 case OT_BYTE:
4138                     gen_op_movzbl_T0_T0();
4139                     break;
4140                 case OT_BYTE | 8:
4141                     gen_op_movsbl_T0_T0();
4142                     break;
4143                 case OT_WORD:
4144                     gen_op_movzwl_T0_T0();
4145                     break;
4146                 default:
4147                 case OT_WORD | 8:
4148                     gen_op_movswl_T0_T0();
4149                     break;
4150                 }
4151                 gen_op_mov_reg_T0[d_ot][reg]();
4152             } else {
4153                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4154                 if (b & 8) {
4155                     gen_op_lds_T0_A0[ot + s->mem_index]();
4156                 } else {
4157                     gen_op_ldu_T0_A0[ot + s->mem_index]();
4158                 }
4159                 gen_op_mov_reg_T0[d_ot][reg]();
4160             }
4161         }
4162         break;
4163
4164     case 0x8d: /* lea */
4165         ot = dflag + OT_WORD;
4166         modrm = ldub_code(s->pc++);
4167         mod = (modrm >> 6) & 3;
4168         if (mod == 3)
4169             goto illegal_op;
4170         reg = ((modrm >> 3) & 7) | rex_r;
4171         /* we must ensure that no segment is added */
4172         s->override = -1;
4173         val = s->addseg;
4174         s->addseg = 0;
4175         gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4176         s->addseg = val;
4177         gen_op_mov_reg_A0[ot - OT_WORD][reg]();
4178         break;
4179
4180     case 0xa0: /* mov EAX, Ov */
4181     case 0xa1:
4182     case 0xa2: /* mov Ov, EAX */
4183     case 0xa3:
4184         {
4185             target_ulong offset_addr;
4186
4187             if ((b & 1) == 0)
4188                 ot = OT_BYTE;
4189             else
4190                 ot = dflag + OT_WORD;
4191 #ifdef TARGET_X86_64
4192             if (s->aflag == 2) {
4193                 offset_addr = ldq_code(s->pc);
4194                 s->pc += 8;
4195                 if (offset_addr == (int32_t)offset_addr)
4196                     gen_op_movq_A0_im(offset_addr);
4197                 else
4198                     gen_op_movq_A0_im64(offset_addr >> 32, offset_addr);
4199             } else
4200 #endif
4201             {
4202                 if (s->aflag) {
4203                     offset_addr = insn_get(s, OT_LONG);
4204                 } else {
4205                     offset_addr = insn_get(s, OT_WORD);
4206                 }
4207                 gen_op_movl_A0_im(offset_addr);
4208             }
4209             gen_add_A0_ds_seg(s);
4210             if ((b & 2) == 0) {
4211                 gen_op_ld_T0_A0[ot + s->mem_index]();
4212                 gen_op_mov_reg_T0[ot][R_EAX]();
4213             } else {
4214                 gen_op_mov_TN_reg[ot][0][R_EAX]();
4215                 gen_op_st_T0_A0[ot + s->mem_index]();
4216             }
4217         }
4218         break;
4219     case 0xd7: /* xlat */
4220 #ifdef TARGET_X86_64
4221         if (s->aflag == 2) {
4222             gen_op_movq_A0_reg[R_EBX]();
4223             gen_op_addq_A0_AL();
4224         } else
4225 #endif
4226         {
4227             gen_op_movl_A0_reg[R_EBX]();
4228             gen_op_addl_A0_AL();
4229             if (s->aflag == 0)
4230                 gen_op_andl_A0_ffff();
4231         }
4232         gen_add_A0_ds_seg(s);
4233         gen_op_ldu_T0_A0[OT_BYTE + s->mem_index]();
4234         gen_op_mov_reg_T0[OT_BYTE][R_EAX]();
4235         break;
4236     case 0xb0 ... 0xb7: /* mov R, Ib */
4237         val = insn_get(s, OT_BYTE);
4238         gen_op_movl_T0_im(val);
4239         gen_op_mov_reg_T0[OT_BYTE][(b & 7) | REX_B(s)]();
4240         break;
4241     case 0xb8 ... 0xbf: /* mov R, Iv */
4242 #ifdef TARGET_X86_64
4243         if (dflag == 2) {
4244             uint64_t tmp;
4245             /* 64 bit case */
4246             tmp = ldq_code(s->pc);
4247             s->pc += 8;
4248             reg = (b & 7) | REX_B(s);
4249             gen_movtl_T0_im(tmp);
4250             gen_op_mov_reg_T0[OT_QUAD][reg]();
4251         } else
4252 #endif
4253         {
4254             ot = dflag ? OT_LONG : OT_WORD;
4255             val = insn_get(s, ot);
4256             reg = (b & 7) | REX_B(s);
4257             gen_op_movl_T0_im(val);
4258             gen_op_mov_reg_T0[ot][reg]();
4259         }
4260         break;
4261
4262     case 0x91 ... 0x97: /* xchg R, EAX */
4263         ot = dflag + OT_WORD;
4264         reg = (b & 7) | REX_B(s);
4265         rm = R_EAX;
4266         goto do_xchg_reg;
4267     case 0x86:
4268     case 0x87: /* xchg Ev, Gv */
4269         if ((b & 1) == 0)
4270             ot = OT_BYTE;
4271         else
4272             ot = dflag + OT_WORD;
4273         modrm = ldub_code(s->pc++);
4274         reg = ((modrm >> 3) & 7) | rex_r;
4275         mod = (modrm >> 6) & 3;
4276         if (mod == 3) {
4277             rm = (modrm & 7) | REX_B(s);
4278         do_xchg_reg:
4279             gen_op_mov_TN_reg[ot][0][reg]();
4280             gen_op_mov_TN_reg[ot][1][rm]();
4281             gen_op_mov_reg_T0[ot][rm]();
4282             gen_op_mov_reg_T1[ot][reg]();
4283         } else {
4284             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4285             gen_op_mov_TN_reg[ot][0][reg]();
4286             /* for xchg, lock is implicit */
4287             if (!(prefixes & PREFIX_LOCK))
4288                 gen_op_lock();
4289             gen_op_ld_T1_A0[ot + s->mem_index]();
4290             gen_op_st_T0_A0[ot + s->mem_index]();
4291             if (!(prefixes & PREFIX_LOCK))
4292                 gen_op_unlock();
4293             gen_op_mov_reg_T1[ot][reg]();
4294         }
4295         break;
4296     case 0xc4: /* les Gv */
4297         if (CODE64(s))
4298             goto illegal_op;
4299         op = R_ES;
4300         goto do_lxx;
4301     case 0xc5: /* lds Gv */
4302         if (CODE64(s))
4303             goto illegal_op;
4304         op = R_DS;
4305         goto do_lxx;
4306     case 0x1b2: /* lss Gv */
4307         op = R_SS;
4308         goto do_lxx;
4309     case 0x1b4: /* lfs Gv */
4310         op = R_FS;
4311         goto do_lxx;
4312     case 0x1b5: /* lgs Gv */
4313         op = R_GS;
4314     do_lxx:
4315         ot = dflag ? OT_LONG : OT_WORD;
4316         modrm = ldub_code(s->pc++);
4317         reg = ((modrm >> 3) & 7) | rex_r;
4318         mod = (modrm >> 6) & 3;
4319         if (mod == 3)
4320             goto illegal_op;
4321         gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4322         gen_op_ld_T1_A0[ot + s->mem_index]();
4323         gen_add_A0_im(s, 1 << (ot - OT_WORD + 1));
4324         /* load the segment first to handle exceptions properly */
4325         gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
4326         gen_movl_seg_T0(s, op, pc_start - s->cs_base);
4327         /* then put the data */
4328         gen_op_mov_reg_T1[ot][reg]();
4329         if (s->is_jmp) {
4330             gen_jmp_im(s->pc - s->cs_base);
4331             gen_eob(s);
4332         }
4333         break;
4334
4335         /************************/
4336         /* shifts */
4337     case 0xc0:
4338     case 0xc1:
4339         /* shift Ev,Ib */
4340         shift = 2;
4341     grp2:
4342         {
4343             if ((b & 1) == 0)
4344                 ot = OT_BYTE;
4345             else
4346                 ot = dflag + OT_WORD;
4347
4348             modrm = ldub_code(s->pc++);
4349             mod = (modrm >> 6) & 3;
4350             op = (modrm >> 3) & 7;
4351
4352             if (mod != 3) {
4353                 if (shift == 2) {
4354                     s->rip_offset = 1;
4355                 }
4356                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4357                 opreg = OR_TMP0;
4358             } else {
4359                 opreg = (modrm & 7) | REX_B(s);
4360             }
4361
4362             /* simpler op */
4363             if (shift == 0) {
4364                 gen_shift(s, op, ot, opreg, OR_ECX);
4365             } else {
4366                 if (shift == 2) {
4367                     shift = ldub_code(s->pc++);
4368                 }
4369                 gen_shifti(s, op, ot, opreg, shift);
4370             }
4371         }
4372         break;
4373     case 0xd0:
4374     case 0xd1:
4375         /* shift Ev,1 */
4376         shift = 1;
4377         goto grp2;
4378     case 0xd2:
4379     case 0xd3:
4380         /* shift Ev,cl */
4381         shift = 0;
4382         goto grp2;
4383
4384     case 0x1a4: /* shld imm */
4385         op = 0;
4386         shift = 1;
4387         goto do_shiftd;
4388     case 0x1a5: /* shld cl */
4389         op = 0;
4390         shift = 0;
4391         goto do_shiftd;
4392     case 0x1ac: /* shrd imm */
4393         op = 1;
4394         shift = 1;
4395         goto do_shiftd;
4396     case 0x1ad: /* shrd cl */
4397         op = 1;
4398         shift = 0;
4399     do_shiftd:
4400         ot = dflag + OT_WORD;
4401         modrm = ldub_code(s->pc++);
4402         mod = (modrm >> 6) & 3;
4403         rm = (modrm & 7) | REX_B(s);
4404         reg = ((modrm >> 3) & 7) | rex_r;
4405
4406         if (mod != 3) {
4407             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4408             gen_op_ld_T0_A0[ot + s->mem_index]();
4409         } else {
4410             gen_op_mov_TN_reg[ot][0][rm]();
4411         }
4412         gen_op_mov_TN_reg[ot][1][reg]();
4413
4414         if (shift) {
4415             val = ldub_code(s->pc++);
4416             if (ot == OT_QUAD)
4417                 val &= 0x3f;
4418             else
4419                 val &= 0x1f;
4420             if (val) {
4421                 if (mod == 3)
4422                     gen_op_shiftd_T0_T1_im_cc[ot][op](val);
4423                 else
4424                     gen_op_shiftd_mem_T0_T1_im_cc[ot + s->mem_index][op](val);
4425                 if (op == 0 && ot != OT_WORD)
4426                     s->cc_op = CC_OP_SHLB + ot;
4427                 else
4428                     s->cc_op = CC_OP_SARB + ot;
4429             }
4430         } else {
4431             if (s->cc_op != CC_OP_DYNAMIC)
4432                 gen_op_set_cc_op(s->cc_op);
4433             if (mod == 3)
4434                 gen_op_shiftd_T0_T1_ECX_cc[ot][op]();
4435             else
4436                 gen_op_shiftd_mem_T0_T1_ECX_cc[ot + s->mem_index][op]();
4437             s->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */
4438         }
4439         if (mod == 3) {
4440             gen_op_mov_reg_T0[ot][rm]();
4441         }
4442         break;
4443
4444         /************************/
4445         /* floats */
4446     case 0xd8 ... 0xdf:
4447         if (s->flags & (HF_EM_MASK | HF_TS_MASK)) {
4448             /* if CR0.EM or CR0.TS are set, generate an FPU exception */
4449             /* XXX: what to do if illegal op ? */
4450             gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
4451             break;
4452         }
4453         modrm = ldub_code(s->pc++);
4454         mod = (modrm >> 6) & 3;
4455         rm = modrm & 7;
4456         op = ((b & 7) << 3) | ((modrm >> 3) & 7);
4457         if (mod != 3) {
4458             /* memory op */
4459             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4460             switch(op) {
4461             case 0x00 ... 0x07: /* fxxxs */
4462             case 0x10 ... 0x17: /* fixxxl */
4463             case 0x20 ... 0x27: /* fxxxl */
4464             case 0x30 ... 0x37: /* fixxx */
4465                 {
4466                     int op1;
4467                     op1 = op & 7;
4468
4469                     switch(op >> 4) {
4470                     case 0:
4471                         gen_op_flds_FT0_A0();
4472                         break;
4473                     case 1:
4474                         gen_op_fildl_FT0_A0();
4475                         break;
4476                     case 2:
4477                         gen_op_fldl_FT0_A0();
4478                         break;
4479                     case 3:
4480                     default:
4481                         gen_op_fild_FT0_A0();
4482                         break;
4483                     }
4484
4485                     gen_op_fp_arith_ST0_FT0[op1]();
4486                     if (op1 == 3) {
4487                         /* fcomp needs pop */
4488                         gen_op_fpop();
4489                     }
4490                 }
4491                 break;
4492             case 0x08: /* flds */
4493             case 0x0a: /* fsts */
4494             case 0x0b: /* fstps */
4495             case 0x18 ... 0x1b: /* fildl, fisttpl, fistl, fistpl */
4496             case 0x28 ... 0x2b: /* fldl, fisttpll, fstl, fstpl */
4497             case 0x38 ... 0x3b: /* filds, fisttps, fists, fistps */
4498                 switch(op & 7) {
4499                 case 0:
4500                     switch(op >> 4) {
4501                     case 0:
4502                         gen_op_flds_ST0_A0();
4503                         break;
4504                     case 1:
4505                         gen_op_fildl_ST0_A0();
4506                         break;
4507                     case 2:
4508                         gen_op_fldl_ST0_A0();
4509                         break;
4510                     case 3:
4511                     default:
4512                         gen_op_fild_ST0_A0();
4513                         break;
4514                     }
4515                     break;
4516                 case 1:
4517                     switch(op >> 4) {
4518                     case 1:
4519                         gen_op_fisttl_ST0_A0();
4520                         break;
4521                     case 2:
4522                         gen_op_fisttll_ST0_A0();
4523                         break;
4524                     case 3:
4525                     default:
4526                         gen_op_fistt_ST0_A0();
4527                     }
4528                     gen_op_fpop();
4529                     break;
4530                 default:
4531                     switch(op >> 4) {
4532                     case 0:
4533                         gen_op_fsts_ST0_A0();
4534                         break;
4535                     case 1:
4536                         gen_op_fistl_ST0_A0();
4537                         break;
4538                     case 2:
4539                         gen_op_fstl_ST0_A0();
4540                         break;
4541                     case 3:
4542                     default:
4543                         gen_op_fist_ST0_A0();
4544                         break;
4545                     }
4546                     if ((op & 7) == 3)
4547                         gen_op_fpop();
4548                     break;
4549                 }
4550                 break;
4551             case 0x0c: /* fldenv mem */
4552                 gen_op_fldenv_A0(s->dflag);
4553                 break;
4554             case 0x0d: /* fldcw mem */
4555                 gen_op_fldcw_A0();
4556                 break;
4557             case 0x0e: /* fnstenv mem */
4558                 gen_op_fnstenv_A0(s->dflag);
4559                 break;
4560             case 0x0f: /* fnstcw mem */
4561                 gen_op_fnstcw_A0();
4562                 break;
4563             case 0x1d: /* fldt mem */
4564                 gen_op_fldt_ST0_A0();
4565                 break;
4566             case 0x1f: /* fstpt mem */
4567                 gen_op_fstt_ST0_A0();
4568                 gen_op_fpop();
4569                 break;
4570             case 0x2c: /* frstor mem */
4571                 gen_op_frstor_A0(s->dflag);
4572                 break;
4573             case 0x2e: /* fnsave mem */
4574                 gen_op_fnsave_A0(s->dflag);
4575                 break;
4576             case 0x2f: /* fnstsw mem */
4577                 gen_op_fnstsw_A0();
4578                 break;
4579             case 0x3c: /* fbld */
4580                 gen_op_fbld_ST0_A0();
4581                 break;
4582             case 0x3e: /* fbstp */
4583                 gen_op_fbst_ST0_A0();
4584                 gen_op_fpop();
4585                 break;
4586             case 0x3d: /* fildll */
4587                 gen_op_fildll_ST0_A0();
4588                 break;
4589             case 0x3f: /* fistpll */
4590                 gen_op_fistll_ST0_A0();
4591                 gen_op_fpop();
4592                 break;
4593             default:
4594                 goto illegal_op;
4595             }
4596         } else {
4597             /* register float ops */
4598             opreg = rm;
4599
4600             switch(op) {
4601             case 0x08: /* fld sti */
4602                 gen_op_fpush();
4603                 gen_op_fmov_ST0_STN((opreg + 1) & 7);
4604                 break;
4605             case 0x09: /* fxchg sti */
4606             case 0x29: /* fxchg4 sti, undocumented op */
4607             case 0x39: /* fxchg7 sti, undocumented op */
4608                 gen_op_fxchg_ST0_STN(opreg);
4609                 break;
4610             case 0x0a: /* grp d9/2 */
4611                 switch(rm) {
4612                 case 0: /* fnop */
4613                     /* check exceptions (FreeBSD FPU probe) */
4614                     if (s->cc_op != CC_OP_DYNAMIC)
4615                         gen_op_set_cc_op(s->cc_op);
4616                     gen_jmp_im(pc_start - s->cs_base);
4617                     gen_op_fwait();
4618                     break;
4619                 default:
4620                     goto illegal_op;
4621                 }
4622                 break;
4623             case 0x0c: /* grp d9/4 */
4624                 switch(rm) {
4625                 case 0: /* fchs */
4626                     gen_op_fchs_ST0();
4627                     break;
4628                 case 1: /* fabs */
4629                     gen_op_fabs_ST0();
4630                     break;
4631                 case 4: /* ftst */
4632                     gen_op_fldz_FT0();
4633                     gen_op_fcom_ST0_FT0();
4634                     break;
4635                 case 5: /* fxam */
4636                     gen_op_fxam_ST0();
4637                     break;
4638                 default:
4639                     goto illegal_op;
4640                 }
4641                 break;
4642             case 0x0d: /* grp d9/5 */
4643                 {
4644                     switch(rm) {
4645                     case 0:
4646                         gen_op_fpush();
4647                         gen_op_fld1_ST0();
4648                         break;
4649                     case 1:
4650                         gen_op_fpush();
4651                         gen_op_fldl2t_ST0();
4652                         break;
4653                     case 2:
4654                         gen_op_fpush();
4655                         gen_op_fldl2e_ST0();
4656                         break;
4657                     case 3:
4658                         gen_op_fpush();
4659                         gen_op_fldpi_ST0();
4660                         break;
4661                     case 4:
4662                         gen_op_fpush();
4663                         gen_op_fldlg2_ST0();
4664                         break;
4665                     case 5:
4666                         gen_op_fpush();
4667                         gen_op_fldln2_ST0();
4668                         break;
4669                     case 6:
4670                         gen_op_fpush();
4671                         gen_op_fldz_ST0();
4672                         break;
4673                     default:
4674                         goto illegal_op;
4675                     }
4676                 }
4677                 break;
4678             case 0x0e: /* grp d9/6 */
4679                 switch(rm) {
4680                 case 0: /* f2xm1 */
4681                     gen_op_f2xm1();
4682                     break;
4683                 case 1: /* fyl2x */
4684                     gen_op_fyl2x();
4685                     break;
4686                 case 2: /* fptan */
4687                     gen_op_fptan();
4688                     break;
4689                 case 3: /* fpatan */
4690                     gen_op_fpatan();
4691                     break;
4692                 case 4: /* fxtract */
4693                     gen_op_fxtract();
4694                     break;
4695                 case 5: /* fprem1 */
4696                     gen_op_fprem1();
4697                     break;
4698                 case 6: /* fdecstp */
4699                     gen_op_fdecstp();
4700                     break;
4701                 default:
4702                 case 7: /* fincstp */
4703                     gen_op_fincstp();
4704                     break;
4705                 }
4706                 break;
4707             case 0x0f: /* grp d9/7 */
4708                 switch(rm) {
4709                 case 0: /* fprem */
4710                     gen_op_fprem();
4711                     break;
4712                 case 1: /* fyl2xp1 */
4713                     gen_op_fyl2xp1();
4714                     break;
4715                 case 2: /* fsqrt */
4716                     gen_op_fsqrt();
4717                     break;
4718                 case 3: /* fsincos */
4719                     gen_op_fsincos();
4720                     break;
4721                 case 5: /* fscale */
4722                     gen_op_fscale();
4723                     break;
4724                 case 4: /* frndint */
4725                     gen_op_frndint();
4726                     break;
4727                 case 6: /* fsin */
4728                     gen_op_fsin();
4729                     break;
4730                 default:
4731                 case 7: /* fcos */
4732                     gen_op_fcos();
4733                     break;
4734                 }
4735                 break;
4736             case 0x00: case 0x01: case 0x04 ... 0x07: /* fxxx st, sti */
4737             case 0x20: case 0x21: case 0x24 ... 0x27: /* fxxx sti, st */
4738             case 0x30: case 0x31: case 0x34 ... 0x37: /* fxxxp sti, st */
4739                 {
4740                     int op1;
4741
4742                     op1 = op & 7;
4743                     if (op >= 0x20) {
4744                         gen_op_fp_arith_STN_ST0[op1](opreg);
4745                         if (op >= 0x30)
4746                             gen_op_fpop();
4747                     } else {
4748                         gen_op_fmov_FT0_STN(opreg);
4749                         gen_op_fp_arith_ST0_FT0[op1]();
4750                     }
4751                 }
4752                 break;
4753             case 0x02: /* fcom */
4754             case 0x22: /* fcom2, undocumented op */
4755                 gen_op_fmov_FT0_STN(opreg);
4756                 gen_op_fcom_ST0_FT0();
4757                 break;
4758             case 0x03: /* fcomp */
4759             case 0x23: /* fcomp3, undocumented op */
4760             case 0x32: /* fcomp5, undocumented op */
4761                 gen_op_fmov_FT0_STN(opreg);
4762                 gen_op_fcom_ST0_FT0();
4763                 gen_op_fpop();
4764                 break;
4765             case 0x15: /* da/5 */
4766                 switch(rm) {
4767                 case 1: /* fucompp */
4768                     gen_op_fmov_FT0_STN(1);
4769                     gen_op_fucom_ST0_FT0();
4770                     gen_op_fpop();
4771                     gen_op_fpop();
4772                     break;
4773                 default:
4774                     goto illegal_op;
4775                 }
4776                 break;
4777             case 0x1c:
4778                 switch(rm) {
4779                 case 0: /* feni (287 only, just do nop here) */
4780                     break;
4781                 case 1: /* fdisi (287 only, just do nop here) */
4782                     break;
4783                 case 2: /* fclex */
4784                     gen_op_fclex();
4785                     break;
4786                 case 3: /* fninit */
4787                     gen_op_fninit();
4788                     break;
4789                 case 4: /* fsetpm (287 only, just do nop here) */
4790                     break;
4791                 default:
4792                     goto illegal_op;
4793                 }
4794                 break;
4795             case 0x1d: /* fucomi */
4796                 if (s->cc_op != CC_OP_DYNAMIC)
4797                     gen_op_set_cc_op(s->cc_op);
4798                 gen_op_fmov_FT0_STN(opreg);
4799                 gen_op_fucomi_ST0_FT0();
4800                 s->cc_op = CC_OP_EFLAGS;
4801                 break;
4802             case 0x1e: /* fcomi */
4803                 if (s->cc_op != CC_OP_DYNAMIC)
4804                     gen_op_set_cc_op(s->cc_op);
4805                 gen_op_fmov_FT0_STN(opreg);
4806                 gen_op_fcomi_ST0_FT0();
4807                 s->cc_op = CC_OP_EFLAGS;
4808                 break;
4809             case 0x28: /* ffree sti */
4810                 gen_op_ffree_STN(opreg);
4811                 break;
4812             case 0x2a: /* fst sti */
4813                 gen_op_fmov_STN_ST0(opreg);
4814                 break;
4815             case 0x2b: /* fstp sti */
4816             case 0x0b: /* fstp1 sti, undocumented op */
4817             case 0x3a: /* fstp8 sti, undocumented op */
4818             case 0x3b: /* fstp9 sti, undocumented op */
4819                 gen_op_fmov_STN_ST0(opreg);
4820                 gen_op_fpop();
4821                 break;
4822             case 0x2c: /* fucom st(i) */
4823                 gen_op_fmov_FT0_STN(opreg);
4824                 gen_op_fucom_ST0_FT0();
4825                 break;
4826             case 0x2d: /* fucomp st(i) */
4827                 gen_op_fmov_FT0_STN(opreg);
4828                 gen_op_fucom_ST0_FT0();
4829                 gen_op_fpop();
4830                 break;
4831             case 0x33: /* de/3 */
4832                 switch(rm) {
4833                 case 1: /* fcompp */
4834                     gen_op_fmov_FT0_STN(1);
4835                     gen_op_fcom_ST0_FT0();
4836                     gen_op_fpop();
4837                     gen_op_fpop();
4838                     break;
4839                 default:
4840                     goto illegal_op;
4841                 }
4842                 break;
4843             case 0x38: /* ffreep sti, undocumented op */
4844                 gen_op_ffree_STN(opreg);
4845                 gen_op_fpop();
4846                 break;
4847             case 0x3c: /* df/4 */
4848                 switch(rm) {
4849                 case 0:
4850                     gen_op_fnstsw_EAX();
4851                     break;
4852                 default:
4853                     goto illegal_op;
4854                 }
4855                 break;
4856             case 0x3d: /* fucomip */
4857                 if (s->cc_op != CC_OP_DYNAMIC)
4858                     gen_op_set_cc_op(s->cc_op);
4859                 gen_op_fmov_FT0_STN(opreg);
4860                 gen_op_fucomi_ST0_FT0();
4861                 gen_op_fpop();
4862                 s->cc_op = CC_OP_EFLAGS;
4863                 break;
4864             case 0x3e: /* fcomip */
4865                 if (s->cc_op != CC_OP_DYNAMIC)
4866                     gen_op_set_cc_op(s->cc_op);
4867                 gen_op_fmov_FT0_STN(opreg);
4868                 gen_op_fcomi_ST0_FT0();
4869                 gen_op_fpop();
4870                 s->cc_op = CC_OP_EFLAGS;
4871                 break;
4872             case 0x10 ... 0x13: /* fcmovxx */
4873             case 0x18 ... 0x1b:
4874                 {
4875                     int op1;
4876                     const static uint8_t fcmov_cc[8] = {
4877                         (JCC_B << 1),
4878                         (JCC_Z << 1),
4879                         (JCC_BE << 1),
4880                         (JCC_P << 1),
4881                     };
4882                     op1 = fcmov_cc[op & 3] | ((op >> 3) & 1);
4883                     gen_setcc(s, op1);
4884                     gen_op_fcmov_ST0_STN_T0(opreg);
4885                 }
4886                 break;
4887             default:
4888                 goto illegal_op;
4889             }
4890         }
4891 #ifdef USE_CODE_COPY
4892         s->tb->cflags |= CF_TB_FP_USED;
4893 #endif
4894         break;
4895         /************************/
4896         /* string ops */
4897
4898     case 0xa4: /* movsS */
4899     case 0xa5:
4900         if ((b & 1) == 0)
4901             ot = OT_BYTE;
4902         else
4903             ot = dflag + OT_WORD;
4904
4905         if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
4906             gen_repz_movs(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
4907         } else {
4908             gen_movs(s, ot);
4909         }
4910         break;
4911
4912     case 0xaa: /* stosS */
4913     case 0xab:
4914         if ((b & 1) == 0)
4915             ot = OT_BYTE;
4916         else
4917             ot = dflag + OT_WORD;
4918
4919         if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
4920             gen_repz_stos(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
4921         } else {
4922             gen_stos(s, ot);
4923         }
4924         break;
4925     case 0xac: /* lodsS */
4926     case 0xad:
4927         if ((b & 1) == 0)
4928             ot = OT_BYTE;
4929         else
4930             ot = dflag + OT_WORD;
4931         if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
4932             gen_repz_lods(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
4933         } else {
4934             gen_lods(s, ot);
4935         }
4936         break;
4937     case 0xae: /* scasS */
4938     case 0xaf:
4939         if ((b & 1) == 0)
4940             ot = OT_BYTE;
4941         else
4942             ot = dflag + OT_WORD;
4943         if (prefixes & PREFIX_REPNZ) {
4944             gen_repz_scas(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 1);
4945         } else if (prefixes & PREFIX_REPZ) {
4946             gen_repz_scas(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 0);
4947         } else {
4948             gen_scas(s, ot);
4949             s->cc_op = CC_OP_SUBB + ot;
4950         }
4951         break;
4952
4953     case 0xa6: /* cmpsS */
4954     case 0xa7:
4955         if ((b & 1) == 0)
4956             ot = OT_BYTE;
4957         else
4958             ot = dflag + OT_WORD;
4959         if (prefixes & PREFIX_REPNZ) {
4960             gen_repz_cmps(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 1);
4961         } else if (prefixes & PREFIX_REPZ) {
4962             gen_repz_cmps(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 0);
4963         } else {
4964             gen_cmps(s, ot);
4965             s->cc_op = CC_OP_SUBB + ot;
4966         }
4967         break;
4968     case 0x6c: /* insS */
4969     case 0x6d:
4970         if ((b & 1) == 0)
4971             ot = OT_BYTE;
4972         else
4973             ot = dflag ? OT_LONG : OT_WORD;
4974         gen_check_io(s, ot, 1, pc_start - s->cs_base);
4975         gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
4976         gen_op_andl_T0_ffff();
4977         if (gen_svm_check_io(s, pc_start,
4978                              SVM_IOIO_TYPE_MASK | (1 << (4+ot)) |
4979                              svm_is_rep(prefixes) | 4 | (1 << (7+s->aflag))))
4980             break;
4981         if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
4982             gen_repz_ins(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
4983         } else {
4984             gen_ins(s, ot);
4985         }
4986         break;
4987     case 0x6e: /* outsS */
4988     case 0x6f:
4989         if ((b & 1) == 0)
4990             ot = OT_BYTE;
4991         else
4992             ot = dflag ? OT_LONG : OT_WORD;
4993         gen_check_io(s, ot, 1, pc_start - s->cs_base);
4994         gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
4995         gen_op_andl_T0_ffff();
4996         if (gen_svm_check_io(s, pc_start,
4997                              (1 << (4+ot)) | svm_is_rep(prefixes) |
4998                              4 | (1 << (7+s->aflag))))
4999             break;
5000         if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
5001             gen_repz_outs(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
5002         } else {
5003             gen_outs(s, ot);
5004         }
5005         break;
5006
5007         /************************/
5008         /* port I/O */
5009
5010     case 0xe4:
5011     case 0xe5:
5012         if ((b & 1) == 0)
5013             ot = OT_BYTE;
5014         else
5015             ot = dflag ? OT_LONG : OT_WORD;
5016         val = ldub_code(s->pc++);
5017         gen_op_movl_T0_im(val);
5018         gen_check_io(s, ot, 0, pc_start - s->cs_base);
5019         if (gen_svm_check_io(s, pc_start,
5020                              SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes) |
5021                              (1 << (4+ot))))
5022             break;
5023         gen_op_in[ot]();
5024         gen_op_mov_reg_T1[ot][R_EAX]();
5025         break;
5026     case 0xe6:
5027     case 0xe7:
5028         if ((b & 1) == 0)
5029             ot = OT_BYTE;
5030         else
5031             ot = dflag ? OT_LONG : OT_WORD;
5032         val = ldub_code(s->pc++);
5033         gen_op_movl_T0_im(val);
5034         gen_check_io(s, ot, 0, pc_start - s->cs_base);
5035         if (gen_svm_check_io(s, pc_start, svm_is_rep(prefixes) |
5036                              (1 << (4+ot))))
5037             break;
5038         gen_op_mov_TN_reg[ot][1][R_EAX]();
5039         gen_op_out[ot]();
5040         break;
5041     case 0xec:
5042     case 0xed:
5043         if ((b & 1) == 0)
5044             ot = OT_BYTE;
5045         else
5046             ot = dflag ? OT_LONG : OT_WORD;
5047         gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
5048         gen_op_andl_T0_ffff();
5049         gen_check_io(s, ot, 0, pc_start - s->cs_base);
5050         if (gen_svm_check_io(s, pc_start,
5051                              SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes) |
5052                              (1 << (4+ot))))
5053             break;
5054         gen_op_in[ot]();
5055         gen_op_mov_reg_T1[ot][R_EAX]();
5056         break;
5057     case 0xee:
5058     case 0xef:
5059         if ((b & 1) == 0)
5060             ot = OT_BYTE;
5061         else
5062             ot = dflag ? OT_LONG : OT_WORD;
5063         gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
5064         gen_op_andl_T0_ffff();
5065         gen_check_io(s, ot, 0, pc_start - s->cs_base);
5066         if (gen_svm_check_io(s, pc_start,
5067                              svm_is_rep(prefixes) | (1 << (4+ot))))
5068             break;
5069         gen_op_mov_TN_reg[ot][1][R_EAX]();
5070         gen_op_out[ot]();
5071         break;
5072
5073         /************************/
5074         /* control */
5075     case 0xc2: /* ret im */
5076         val = ldsw_code(s->pc);
5077         s->pc += 2;
5078         gen_pop_T0(s);
5079         if (CODE64(s) && s->dflag)
5080             s->dflag = 2;
5081         gen_stack_update(s, val + (2 << s->dflag));
5082         if (s->dflag == 0)
5083             gen_op_andl_T0_ffff();
5084         gen_op_jmp_T0();
5085         gen_eob(s);
5086         break;
5087     case 0xc3: /* ret */
5088         gen_pop_T0(s);
5089         gen_pop_update(s);
5090         if (s->dflag == 0)
5091             gen_op_andl_T0_ffff();
5092         gen_op_jmp_T0();
5093         gen_eob(s);
5094         break;
5095     case 0xca: /* lret im */
5096         val = ldsw_code(s->pc);
5097         s->pc += 2;
5098     do_lret:
5099         if (s->pe && !s->vm86) {
5100             if (s->cc_op != CC_OP_DYNAMIC)
5101                 gen_op_set_cc_op(s->cc_op);
5102             gen_jmp_im(pc_start - s->cs_base);
5103             gen_op_lret_protected(s->dflag, val);
5104         } else {
5105             gen_stack_A0(s);
5106             /* pop offset */
5107             gen_op_ld_T0_A0[1 + s->dflag + s->mem_index]();
5108             if (s->dflag == 0)
5109                 gen_op_andl_T0_ffff();
5110             /* NOTE: keeping EIP updated is not a problem in case of
5111                exception */
5112             gen_op_jmp_T0();
5113             /* pop selector */
5114             gen_op_addl_A0_im(2 << s->dflag);
5115             gen_op_ld_T0_A0[1 + s->dflag + s->mem_index]();
5116             gen_op_movl_seg_T0_vm(offsetof(CPUX86State,segs[R_CS]));
5117             /* add stack offset */
5118             gen_stack_update(s, val + (4 << s->dflag));
5119         }
5120         gen_eob(s);
5121         break;
5122     case 0xcb: /* lret */
5123         val = 0;
5124         goto do_lret;
5125     case 0xcf: /* iret */
5126         if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_IRET))
5127             break;
5128         if (!s->pe) {
5129             /* real mode */
5130             gen_op_iret_real(s->dflag);
5131             s->cc_op = CC_OP_EFLAGS;
5132         } else if (s->vm86) {
5133             if (s->iopl != 3) {
5134                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5135             } else {
5136                 gen_op_iret_real(s->dflag);
5137                 s->cc_op = CC_OP_EFLAGS;
5138             }
5139         } else {
5140             if (s->cc_op != CC_OP_DYNAMIC)
5141                 gen_op_set_cc_op(s->cc_op);
5142             gen_jmp_im(pc_start - s->cs_base);
5143             gen_op_iret_protected(s->dflag, s->pc - s->cs_base);
5144             s->cc_op = CC_OP_EFLAGS;
5145         }
5146         gen_eob(s);
5147         break;
5148     case 0xe8: /* call im */
5149         {
5150             if (dflag)
5151                 tval = (int32_t)insn_get(s, OT_LONG);
5152             else
5153                 tval = (int16_t)insn_get(s, OT_WORD);
5154             next_eip = s->pc - s->cs_base;
5155             tval += next_eip;
5156             if (s->dflag == 0)
5157                 tval &= 0xffff;
5158             gen_movtl_T0_im(next_eip);
5159             gen_push_T0(s);
5160             gen_jmp(s, tval);
5161         }
5162         break;
5163     case 0x9a: /* lcall im */
5164         {
5165             unsigned int selector, offset;
5166
5167             if (CODE64(s))
5168                 goto illegal_op;
5169             ot = dflag ? OT_LONG : OT_WORD;
5170             offset = insn_get(s, ot);
5171             selector = insn_get(s, OT_WORD);
5172
5173             gen_op_movl_T0_im(selector);
5174             gen_op_movl_T1_imu(offset);
5175         }
5176         goto do_lcall;
5177     case 0xe9: /* jmp im */
5178         if (dflag)
5179             tval = (int32_t)insn_get(s, OT_LONG);
5180         else
5181             tval = (int16_t)insn_get(s, OT_WORD);
5182         tval += s->pc - s->cs_base;
5183         if (s->dflag == 0)
5184             tval &= 0xffff;
5185         gen_jmp(s, tval);
5186         break;
5187     case 0xea: /* ljmp im */
5188         {
5189             unsigned int selector, offset;
5190
5191             if (CODE64(s))
5192                 goto illegal_op;
5193             ot = dflag ? OT_LONG : OT_WORD;
5194             offset = insn_get(s, ot);
5195             selector = insn_get(s, OT_WORD);
5196
5197             gen_op_movl_T0_im(selector);
5198             gen_op_movl_T1_imu(offset);
5199         }
5200         goto do_ljmp;
5201     case 0xeb: /* jmp Jb */
5202         tval = (int8_t)insn_get(s, OT_BYTE);
5203         tval += s->pc - s->cs_base;
5204         if (s->dflag == 0)
5205             tval &= 0xffff;
5206         gen_jmp(s, tval);
5207         break;
5208     case 0x70 ... 0x7f: /* jcc Jb */
5209         tval = (int8_t)insn_get(s, OT_BYTE);
5210         goto do_jcc;
5211     case 0x180 ... 0x18f: /* jcc Jv */
5212         if (dflag) {
5213             tval = (int32_t)insn_get(s, OT_LONG);
5214         } else {
5215             tval = (int16_t)insn_get(s, OT_WORD);
5216         }
5217     do_jcc:
5218         next_eip = s->pc - s->cs_base;
5219         tval += next_eip;
5220         if (s->dflag == 0)
5221             tval &= 0xffff;
5222         gen_jcc(s, b, tval, next_eip);
5223         break;
5224
5225     case 0x190 ... 0x19f: /* setcc Gv */
5226         modrm = ldub_code(s->pc++);
5227         gen_setcc(s, b);
5228         gen_ldst_modrm(s, modrm, OT_BYTE, OR_TMP0, 1);
5229         break;
5230     case 0x140 ... 0x14f: /* cmov Gv, Ev */
5231         ot = dflag + OT_WORD;
5232         modrm = ldub_code(s->pc++);
5233         reg = ((modrm >> 3) & 7) | rex_r;
5234         mod = (modrm >> 6) & 3;
5235         gen_setcc(s, b);
5236         if (mod != 3) {
5237             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5238             gen_op_ld_T1_A0[ot + s->mem_index]();
5239         } else {
5240             rm = (modrm & 7) | REX_B(s);
5241             gen_op_mov_TN_reg[ot][1][rm]();
5242         }
5243         gen_op_cmov_reg_T1_T0[ot - OT_WORD][reg]();
5244         break;
5245
5246         /************************/
5247         /* flags */
5248     case 0x9c: /* pushf */
5249         if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_PUSHF))
5250             break;
5251         if (s->vm86 && s->iopl != 3) {
5252             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5253         } else {
5254             if (s->cc_op != CC_OP_DYNAMIC)
5255                 gen_op_set_cc_op(s->cc_op);
5256             gen_op_movl_T0_eflags();
5257             gen_push_T0(s);
5258         }
5259         break;
5260     case 0x9d: /* popf */
5261         if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_POPF))
5262             break;
5263         if (s->vm86 && s->iopl != 3) {
5264             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5265         } else {
5266             gen_pop_T0(s);
5267             if (s->cpl == 0) {
5268                 if (s->dflag) {
5269                     gen_op_movl_eflags_T0_cpl0();
5270                 } else {
5271                     gen_op_movw_eflags_T0_cpl0();
5272                 }
5273             } else {
5274                 if (s->cpl <= s->iopl) {
5275                     if (s->dflag) {
5276                         gen_op_movl_eflags_T0_io();
5277                     } else {
5278                         gen_op_movw_eflags_T0_io();
5279                     }
5280                 } else {
5281                     if (s->dflag) {
5282                         gen_op_movl_eflags_T0();
5283                     } else {
5284                         gen_op_movw_eflags_T0();
5285                     }
5286                 }
5287             }
5288             gen_pop_update(s);
5289             s->cc_op = CC_OP_EFLAGS;
5290             /* abort translation because TF flag may change */
5291             gen_jmp_im(s->pc - s->cs_base);
5292             gen_eob(s);
5293         }
5294         break;
5295     case 0x9e: /* sahf */
5296         if (CODE64(s))
5297             goto illegal_op;
5298         gen_op_mov_TN_reg[OT_BYTE][0][R_AH]();
5299         if (s->cc_op != CC_OP_DYNAMIC)
5300             gen_op_set_cc_op(s->cc_op);
5301         gen_op_movb_eflags_T0();
5302         s->cc_op = CC_OP_EFLAGS;
5303         break;
5304     case 0x9f: /* lahf */
5305         if (CODE64(s))
5306             goto illegal_op;
5307         if (s->cc_op != CC_OP_DYNAMIC)
5308             gen_op_set_cc_op(s->cc_op);
5309         gen_op_movl_T0_eflags();
5310         gen_op_mov_reg_T0[OT_BYTE][R_AH]();
5311         break;
5312     case 0xf5: /* cmc */
5313         if (s->cc_op != CC_OP_DYNAMIC)
5314             gen_op_set_cc_op(s->cc_op);
5315         gen_op_cmc();
5316         s->cc_op = CC_OP_EFLAGS;
5317         break;
5318     case 0xf8: /* clc */
5319         if (s->cc_op != CC_OP_DYNAMIC)
5320             gen_op_set_cc_op(s->cc_op);
5321         gen_op_clc();
5322         s->cc_op = CC_OP_EFLAGS;
5323         break;
5324     case 0xf9: /* stc */
5325         if (s->cc_op != CC_OP_DYNAMIC)
5326             gen_op_set_cc_op(s->cc_op);
5327         gen_op_stc();
5328         s->cc_op = CC_OP_EFLAGS;
5329         break;
5330     case 0xfc: /* cld */
5331         gen_op_cld();
5332         break;
5333     case 0xfd: /* std */
5334         gen_op_std();
5335         break;
5336
5337         /************************/
5338         /* bit operations */
5339     case 0x1ba: /* bt/bts/btr/btc Gv, im */
5340         ot = dflag + OT_WORD;
5341         modrm = ldub_code(s->pc++);
5342         op = (modrm >> 3) & 7;
5343         mod = (modrm >> 6) & 3;
5344         rm = (modrm & 7) | REX_B(s);
5345         if (mod != 3) {
5346             s->rip_offset = 1;
5347             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5348             gen_op_ld_T0_A0[ot + s->mem_index]();
5349         } else {
5350             gen_op_mov_TN_reg[ot][0][rm]();
5351         }
5352         /* load shift */
5353         val = ldub_code(s->pc++);
5354         gen_op_movl_T1_im(val);
5355         if (op < 4)
5356             goto illegal_op;
5357         op -= 4;
5358         gen_op_btx_T0_T1_cc[ot - OT_WORD][op]();
5359         s->cc_op = CC_OP_SARB + ot;
5360         if (op != 0) {
5361             if (mod != 3)
5362                 gen_op_st_T0_A0[ot + s->mem_index]();
5363             else
5364                 gen_op_mov_reg_T0[ot][rm]();
5365             gen_op_update_bt_cc();
5366         }
5367         break;
5368     case 0x1a3: /* bt Gv, Ev */
5369         op = 0;
5370         goto do_btx;
5371     case 0x1ab: /* bts */
5372         op = 1;
5373         goto do_btx;
5374     case 0x1b3: /* btr */
5375         op = 2;
5376         goto do_btx;
5377     case 0x1bb: /* btc */
5378         op = 3;
5379     do_btx:
5380         ot = dflag + OT_WORD;
5381         modrm = ldub_code(s->pc++);
5382         reg = ((modrm >> 3) & 7) | rex_r;
5383         mod = (modrm >> 6) & 3;
5384         rm = (modrm & 7) | REX_B(s);
5385         gen_op_mov_TN_reg[OT_LONG][1][reg]();
5386         if (mod != 3) {
5387             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5388             /* specific case: we need to add a displacement */
5389             gen_op_add_bit_A0_T1[ot - OT_WORD]();
5390             gen_op_ld_T0_A0[ot + s->mem_index]();
5391         } else {
5392             gen_op_mov_TN_reg[ot][0][rm]();
5393         }
5394         gen_op_btx_T0_T1_cc[ot - OT_WORD][op]();
5395         s->cc_op = CC_OP_SARB + ot;
5396         if (op != 0) {
5397             if (mod != 3)
5398                 gen_op_st_T0_A0[ot + s->mem_index]();
5399             else
5400                 gen_op_mov_reg_T0[ot][rm]();
5401             gen_op_update_bt_cc();
5402         }
5403         break;
5404     case 0x1bc: /* bsf */
5405     case 0x1bd: /* bsr */
5406         ot = dflag + OT_WORD;
5407         modrm = ldub_code(s->pc++);
5408         reg = ((modrm >> 3) & 7) | rex_r;
5409         gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
5410         /* NOTE: in order to handle the 0 case, we must load the
5411            result. It could be optimized with a generated jump */
5412         gen_op_mov_TN_reg[ot][1][reg]();
5413         gen_op_bsx_T0_cc[ot - OT_WORD][b & 1]();
5414         gen_op_mov_reg_T1[ot][reg]();
5415         s->cc_op = CC_OP_LOGICB + ot;
5416         break;
5417         /************************/
5418         /* bcd */
5419     case 0x27: /* daa */
5420         if (CODE64(s))
5421             goto illegal_op;
5422         if (s->cc_op != CC_OP_DYNAMIC)
5423             gen_op_set_cc_op(s->cc_op);
5424         gen_op_daa();
5425         s->cc_op = CC_OP_EFLAGS;
5426         break;
5427     case 0x2f: /* das */
5428         if (CODE64(s))
5429             goto illegal_op;
5430         if (s->cc_op != CC_OP_DYNAMIC)
5431             gen_op_set_cc_op(s->cc_op);
5432         gen_op_das();
5433         s->cc_op = CC_OP_EFLAGS;
5434         break;
5435     case 0x37: /* aaa */
5436         if (CODE64(s))
5437             goto illegal_op;
5438         if (s->cc_op != CC_OP_DYNAMIC)
5439             gen_op_set_cc_op(s->cc_op);
5440         gen_op_aaa();
5441         s->cc_op = CC_OP_EFLAGS;
5442         break;
5443     case 0x3f: /* aas */
5444         if (CODE64(s))
5445             goto illegal_op;
5446         if (s->cc_op != CC_OP_DYNAMIC)
5447             gen_op_set_cc_op(s->cc_op);
5448         gen_op_aas();
5449         s->cc_op = CC_OP_EFLAGS;
5450         break;
5451     case 0xd4: /* aam */
5452         if (CODE64(s))
5453             goto illegal_op;
5454         val = ldub_code(s->pc++);
5455         if (val == 0) {
5456             gen_exception(s, EXCP00_DIVZ, pc_start - s->cs_base);
5457         } else {
5458             gen_op_aam(val);
5459             s->cc_op = CC_OP_LOGICB;
5460         }
5461         break;
5462     case 0xd5: /* aad */
5463         if (CODE64(s))
5464             goto illegal_op;
5465         val = ldub_code(s->pc++);
5466         gen_op_aad(val);
5467         s->cc_op = CC_OP_LOGICB;
5468         break;
5469         /************************/
5470         /* misc */
5471     case 0x90: /* nop */
5472         /* XXX: xchg + rex handling */
5473         /* XXX: correct lock test for all insn */
5474         if (prefixes & PREFIX_LOCK)
5475             goto illegal_op;
5476         if (prefixes & PREFIX_REPZ) {
5477             gen_svm_check_intercept(s, pc_start, SVM_EXIT_PAUSE);
5478         }
5479         break;
5480     case 0x9b: /* fwait */
5481         if ((s->flags & (HF_MP_MASK | HF_TS_MASK)) ==
5482             (HF_MP_MASK | HF_TS_MASK)) {
5483             gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
5484         } else {
5485             if (s->cc_op != CC_OP_DYNAMIC)
5486                 gen_op_set_cc_op(s->cc_op);
5487             gen_jmp_im(pc_start - s->cs_base);
5488             gen_op_fwait();
5489         }
5490         break;
5491     case 0xcc: /* int3 */
5492         if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_SWINT))
5493             break;
5494         gen_interrupt(s, EXCP03_INT3, pc_start - s->cs_base, s->pc - s->cs_base);
5495         break;
5496     case 0xcd: /* int N */
5497         val = ldub_code(s->pc++);
5498         if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_SWINT))
5499             break;
5500         if (s->vm86 && s->iopl != 3) {
5501             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5502         } else {
5503             gen_interrupt(s, val, pc_start - s->cs_base, s->pc - s->cs_base);
5504         }
5505         break;
5506     case 0xce: /* into */
5507         if (CODE64(s))
5508             goto illegal_op;
5509         if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_SWINT))
5510             break;
5511         if (s->cc_op != CC_OP_DYNAMIC)
5512             gen_op_set_cc_op(s->cc_op);
5513         gen_jmp_im(pc_start - s->cs_base);
5514         gen_op_into(s->pc - pc_start);
5515         break;
5516     case 0xf1: /* icebp (undocumented, exits to external debugger) */
5517         if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_ICEBP))
5518             break;
5519 #if 1
5520         gen_debug(s, pc_start - s->cs_base);
5521 #else
5522         /* start debug */
5523         tb_flush(cpu_single_env);
5524         cpu_set_log(CPU_LOG_INT | CPU_LOG_TB_IN_ASM);
5525 #endif
5526         break;
5527     case 0xfa: /* cli */
5528         if (!s->vm86) {
5529             if (s->cpl <= s->iopl) {
5530                 gen_op_cli();
5531             } else {
5532                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5533             }
5534         } else {
5535             if (s->iopl == 3) {
5536                 gen_op_cli();
5537             } else {
5538                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5539             }
5540         }
5541         break;
5542     case 0xfb: /* sti */
5543         if (!s->vm86) {
5544             if (s->cpl <= s->iopl) {
5545             gen_sti:
5546                 gen_op_sti();
5547                 /* interruptions are enabled only the first insn after sti */
5548                 /* If several instructions disable interrupts, only the
5549                    _first_ does it */
5550                 if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
5551                     gen_op_set_inhibit_irq();
5552                 /* give a chance to handle pending irqs */
5553                 gen_jmp_im(s->pc - s->cs_base);
5554                 gen_eob(s);
5555             } else {
5556                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5557             }
5558         } else {
5559             if (s->iopl == 3) {
5560                 goto gen_sti;
5561             } else {
5562                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5563             }
5564         }
5565         break;
5566     case 0x62: /* bound */
5567         if (CODE64(s))
5568             goto illegal_op;
5569         ot = dflag ? OT_LONG : OT_WORD;
5570         modrm = ldub_code(s->pc++);
5571         reg = (modrm >> 3) & 7;
5572         mod = (modrm >> 6) & 3;
5573         if (mod == 3)
5574             goto illegal_op;
5575         gen_op_mov_TN_reg[ot][0][reg]();
5576         gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5577         gen_jmp_im(pc_start - s->cs_base);
5578         if (ot == OT_WORD)
5579             gen_op_boundw();
5580         else
5581             gen_op_boundl();
5582         break;
5583     case 0x1c8 ... 0x1cf: /* bswap reg */
5584         reg = (b & 7) | REX_B(s);
5585 #ifdef TARGET_X86_64
5586         if (dflag == 2) {
5587             gen_op_mov_TN_reg[OT_QUAD][0][reg]();
5588             gen_op_bswapq_T0();
5589             gen_op_mov_reg_T0[OT_QUAD][reg]();
5590         } else
5591 #endif
5592         {
5593             gen_op_mov_TN_reg[OT_LONG][0][reg]();
5594             gen_op_bswapl_T0();
5595             gen_op_mov_reg_T0[OT_LONG][reg]();
5596         }
5597         break;
5598     case 0xd6: /* salc */
5599         if (CODE64(s))
5600             goto illegal_op;
5601         if (s->cc_op != CC_OP_DYNAMIC)
5602             gen_op_set_cc_op(s->cc_op);
5603         gen_op_salc();
5604         break;
5605     case 0xe0: /* loopnz */
5606     case 0xe1: /* loopz */
5607         if (s->cc_op != CC_OP_DYNAMIC)
5608             gen_op_set_cc_op(s->cc_op);
5609         /* FALL THRU */
5610     case 0xe2: /* loop */
5611     case 0xe3: /* jecxz */
5612         {
5613             int l1, l2;
5614
5615             tval = (int8_t)insn_get(s, OT_BYTE);
5616             next_eip = s->pc - s->cs_base;
5617             tval += next_eip;
5618             if (s->dflag == 0)
5619                 tval &= 0xffff;
5620
5621             l1 = gen_new_label();
5622             l2 = gen_new_label();
5623             b &= 3;
5624             if (b == 3) {
5625                 gen_op_jz_ecx[s->aflag](l1);
5626             } else {
5627                 gen_op_dec_ECX[s->aflag]();
5628                 if (b <= 1)
5629                     gen_op_mov_T0_cc();
5630                 gen_op_loop[s->aflag][b](l1);
5631             }
5632
5633             gen_jmp_im(next_eip);
5634             gen_op_jmp_label(l2);
5635             gen_set_label(l1);
5636             gen_jmp_im(tval);
5637             gen_set_label(l2);
5638             gen_eob(s);
5639         }
5640         break;
5641     case 0x130: /* wrmsr */
5642     case 0x132: /* rdmsr */
5643         if (s->cpl != 0) {
5644             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5645         } else {
5646             int retval = 0;
5647             if (b & 2) {
5648                 retval = gen_svm_check_intercept_param(s, pc_start, SVM_EXIT_MSR, 0);
5649                 gen_op_rdmsr();
5650             } else {
5651                 retval = gen_svm_check_intercept_param(s, pc_start, SVM_EXIT_MSR, 1);
5652                 gen_op_wrmsr();
5653             }
5654             if(retval)
5655                 gen_eob(s);
5656         }
5657         break;
5658     case 0x131: /* rdtsc */
5659         if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_RDTSC))
5660             break;
5661         gen_jmp_im(pc_start - s->cs_base);
5662         gen_op_rdtsc();
5663         break;
5664     case 0x134: /* sysenter */
5665         if (CODE64(s))
5666             goto illegal_op;
5667         if (!s->pe) {
5668             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5669         } else {
5670             if (s->cc_op != CC_OP_DYNAMIC) {
5671                 gen_op_set_cc_op(s->cc_op);
5672                 s->cc_op = CC_OP_DYNAMIC;
5673             }
5674             gen_jmp_im(pc_start - s->cs_base);
5675             gen_op_sysenter();
5676             gen_eob(s);
5677         }
5678         break;
5679     case 0x135: /* sysexit */
5680         if (CODE64(s))
5681             goto illegal_op;
5682         if (!s->pe) {
5683             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5684         } else {
5685             if (s->cc_op != CC_OP_DYNAMIC) {
5686                 gen_op_set_cc_op(s->cc_op);
5687                 s->cc_op = CC_OP_DYNAMIC;
5688             }
5689             gen_jmp_im(pc_start - s->cs_base);
5690             gen_op_sysexit();
5691             gen_eob(s);
5692         }
5693         break;
5694 #ifdef TARGET_X86_64
5695     case 0x105: /* syscall */
5696         /* XXX: is it usable in real mode ? */
5697         if (s->cc_op != CC_OP_DYNAMIC) {
5698             gen_op_set_cc_op(s->cc_op);
5699             s->cc_op = CC_OP_DYNAMIC;
5700         }
5701         gen_jmp_im(pc_start - s->cs_base);
5702         gen_op_syscall(s->pc - pc_start);
5703         gen_eob(s);
5704         break;
5705     case 0x107: /* sysret */
5706         if (!s->pe) {
5707             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5708         } else {
5709             if (s->cc_op != CC_OP_DYNAMIC) {
5710                 gen_op_set_cc_op(s->cc_op);
5711                 s->cc_op = CC_OP_DYNAMIC;
5712             }
5713             gen_jmp_im(pc_start - s->cs_base);
5714             gen_op_sysret(s->dflag);
5715             /* condition codes are modified only in long mode */
5716             if (s->lma)
5717                 s->cc_op = CC_OP_EFLAGS;
5718             gen_eob(s);
5719         }
5720         break;
5721 #endif
5722     case 0x1a2: /* cpuid */
5723         if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_CPUID))
5724             break;
5725         gen_op_cpuid();
5726         break;
5727     case 0xf4: /* hlt */
5728         if (s->cpl != 0) {
5729             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5730         } else {
5731             if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_HLT))
5732                 break;
5733             if (s->cc_op != CC_OP_DYNAMIC)
5734                 gen_op_set_cc_op(s->cc_op);
5735             gen_jmp_im(s->pc - s->cs_base);
5736             gen_op_hlt();
5737             s->is_jmp = 3;
5738         }
5739         break;
5740     case 0x100:
5741         modrm = ldub_code(s->pc++);
5742         mod = (modrm >> 6) & 3;
5743         op = (modrm >> 3) & 7;
5744         switch(op) {
5745         case 0: /* sldt */
5746             if (!s->pe || s->vm86)
5747                 goto illegal_op;
5748             if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_LDTR_READ))
5749                 break;
5750             gen_op_movl_T0_env(offsetof(CPUX86State,ldt.selector));
5751             ot = OT_WORD;
5752             if (mod == 3)
5753                 ot += s->dflag;
5754             gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
5755             break;
5756         case 2: /* lldt */
5757             if (!s->pe || s->vm86)
5758                 goto illegal_op;
5759             if (s->cpl != 0) {
5760                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5761             } else {
5762                 if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_LDTR_WRITE))
5763                     break;
5764                 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
5765                 gen_jmp_im(pc_start - s->cs_base);
5766                 gen_op_lldt_T0();
5767             }
5768             break;
5769         case 1: /* str */
5770             if (!s->pe || s->vm86)
5771                 goto illegal_op;
5772             if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_TR_READ))
5773                 break;
5774             gen_op_movl_T0_env(offsetof(CPUX86State,tr.selector));
5775             ot = OT_WORD;
5776             if (mod == 3)
5777                 ot += s->dflag;
5778             gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
5779             break;
5780         case 3: /* ltr */
5781             if (!s->pe || s->vm86)
5782                 goto illegal_op;
5783             if (s->cpl != 0) {
5784                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5785             } else {
5786                 if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_TR_WRITE))
5787                     break;
5788                 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
5789                 gen_jmp_im(pc_start - s->cs_base);
5790                 gen_op_ltr_T0();
5791             }
5792             break;
5793         case 4: /* verr */
5794         case 5: /* verw */
5795             if (!s->pe || s->vm86)
5796                 goto illegal_op;
5797             gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
5798             if (s->cc_op != CC_OP_DYNAMIC)
5799                 gen_op_set_cc_op(s->cc_op);
5800             if (op == 4)
5801                 gen_op_verr();
5802             else
5803                 gen_op_verw();
5804             s->cc_op = CC_OP_EFLAGS;
5805             break;
5806         default:
5807             goto illegal_op;
5808         }
5809         break;
5810     case 0x101:
5811         modrm = ldub_code(s->pc++);
5812         mod = (modrm >> 6) & 3;
5813         op = (modrm >> 3) & 7;
5814         rm = modrm & 7;
5815         switch(op) {
5816         case 0: /* sgdt */
5817             if (mod == 3)
5818                 goto illegal_op;
5819             if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_GDTR_READ))
5820                 break;
5821             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5822             gen_op_movl_T0_env(offsetof(CPUX86State, gdt.limit));
5823             gen_op_st_T0_A0[OT_WORD + s->mem_index]();
5824             gen_add_A0_im(s, 2);
5825             gen_op_movtl_T0_env(offsetof(CPUX86State, gdt.base));
5826             if (!s->dflag)
5827                 gen_op_andl_T0_im(0xffffff);
5828             gen_op_st_T0_A0[CODE64(s) + OT_LONG + s->mem_index]();
5829             break;
5830         case 1:
5831             if (mod == 3) {
5832                 switch (rm) {
5833                 case 0: /* monitor */
5834                     if (!(s->cpuid_ext_features & CPUID_EXT_MONITOR) ||
5835                         s->cpl != 0)
5836                         goto illegal_op;
5837                     if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_MONITOR))
5838                         break;
5839                     gen_jmp_im(pc_start - s->cs_base);
5840 #ifdef TARGET_X86_64
5841                     if (s->aflag == 2) {
5842                         gen_op_movq_A0_reg[R_EBX]();
5843                         gen_op_addq_A0_AL();
5844                     } else
5845 #endif
5846                     {
5847                         gen_op_movl_A0_reg[R_EBX]();
5848                         gen_op_addl_A0_AL();
5849                         if (s->aflag == 0)
5850                             gen_op_andl_A0_ffff();
5851                     }
5852                     gen_add_A0_ds_seg(s);
5853                     gen_op_monitor();
5854                     break;
5855                 case 1: /* mwait */
5856                     if (!(s->cpuid_ext_features & CPUID_EXT_MONITOR) ||
5857                         s->cpl != 0)
5858                         goto illegal_op;
5859                     if (s->cc_op != CC_OP_DYNAMIC) {
5860                         gen_op_set_cc_op(s->cc_op);
5861                         s->cc_op = CC_OP_DYNAMIC;
5862                     }
5863                     if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_MWAIT))
5864                         break;
5865                     gen_jmp_im(s->pc - s->cs_base);
5866                     gen_op_mwait();
5867                     gen_eob(s);
5868                     break;
5869                 default:
5870                     goto illegal_op;
5871                 }
5872             } else { /* sidt */
5873                 if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_IDTR_READ))
5874                     break;
5875                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5876                 gen_op_movl_T0_env(offsetof(CPUX86State, idt.limit));
5877                 gen_op_st_T0_A0[OT_WORD + s->mem_index]();
5878                 gen_add_A0_im(s, 2);
5879                 gen_op_movtl_T0_env(offsetof(CPUX86State, idt.base));
5880                 if (!s->dflag)
5881                     gen_op_andl_T0_im(0xffffff);
5882                 gen_op_st_T0_A0[CODE64(s) + OT_LONG + s->mem_index]();
5883             }
5884             break;
5885         case 2: /* lgdt */
5886         case 3: /* lidt */
5887             if (mod == 3) {
5888                 switch(rm) {
5889                 case 0: /* VMRUN */
5890                     if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_VMRUN))
5891                         break;
5892                     if (s->cc_op != CC_OP_DYNAMIC)
5893                         gen_op_set_cc_op(s->cc_op);
5894                     gen_jmp_im(s->pc - s->cs_base);
5895                     gen_op_vmrun();
5896                     s->cc_op = CC_OP_EFLAGS;
5897                     gen_eob(s);
5898                     break;
5899                 case 1: /* VMMCALL */
5900                     if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_VMMCALL))
5901                          break;
5902                     /* FIXME: cause #UD if hflags & SVM */
5903                     gen_op_vmmcall();
5904                     break;
5905                 case 2: /* VMLOAD */
5906                     if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_VMLOAD))
5907                          break;
5908                     gen_op_vmload();
5909                     break;
5910                 case 3: /* VMSAVE */
5911                     if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_VMSAVE))
5912                          break;
5913                     gen_op_vmsave();
5914                     break;
5915                 case 4: /* STGI */
5916                     if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_STGI))
5917                          break;
5918                     gen_op_stgi();
5919                     break;
5920                 case 5: /* CLGI */
5921                     if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_CLGI))
5922                          break;
5923                     gen_op_clgi();
5924                     break;
5925                 case 6: /* SKINIT */
5926                     if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_SKINIT))
5927                          break;
5928                     gen_op_skinit();
5929                     break;
5930                 case 7: /* INVLPGA */
5931                     if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_INVLPGA))
5932                          break;
5933                     gen_op_invlpga();
5934                     break;
5935                 default:
5936                     goto illegal_op;
5937                 }
5938             } else if (s->cpl != 0) {
5939                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5940             } else {
5941                 if (gen_svm_check_intercept(s, pc_start,
5942                                             op==2 ? SVM_EXIT_GDTR_WRITE : SVM_EXIT_IDTR_WRITE))
5943                     break;
5944                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5945                 gen_op_ld_T1_A0[OT_WORD + s->mem_index]();
5946                 gen_add_A0_im(s, 2);
5947                 gen_op_ld_T0_A0[CODE64(s) + OT_LONG + s->mem_index]();
5948                 if (!s->dflag)
5949                     gen_op_andl_T0_im(0xffffff);
5950                 if (op == 2) {
5951                     gen_op_movtl_env_T0(offsetof(CPUX86State,gdt.base));
5952                     gen_op_movl_env_T1(offsetof(CPUX86State,gdt.limit));
5953                 } else {
5954                     gen_op_movtl_env_T0(offsetof(CPUX86State,idt.base));
5955                     gen_op_movl_env_T1(offsetof(CPUX86State,idt.limit));
5956                 }
5957             }
5958             break;
5959         case 4: /* smsw */
5960             if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_READ_CR0))
5961                 break;
5962             gen_op_movl_T0_env(offsetof(CPUX86State,cr[0]));
5963             gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 1);
5964             break;
5965         case 6: /* lmsw */
5966             if (s->cpl != 0) {
5967                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5968             } else {
5969                 if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_CR0))
5970                     break;
5971                 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
5972                 gen_op_lmsw_T0();
5973                 gen_jmp_im(s->pc - s->cs_base);
5974                 gen_eob(s);
5975             }
5976             break;
5977         case 7: /* invlpg */
5978             if (s->cpl != 0) {
5979                 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
5980             } else {
5981                 if (mod == 3) {
5982 #ifdef TARGET_X86_64
5983                     if (CODE64(s) && rm == 0) {
5984                         /* swapgs */
5985                         gen_op_movtl_T0_env(offsetof(CPUX86State,segs[R_GS].base));
5986                         gen_op_movtl_T1_env(offsetof(CPUX86State,kernelgsbase));
5987                         gen_op_movtl_env_T1(offsetof(CPUX86State,segs[R_GS].base));
5988                         gen_op_movtl_env_T0(offsetof(CPUX86State,kernelgsbase));
5989                     } else
5990 #endif
5991                     {
5992                         goto illegal_op;
5993                     }
5994                 } else {
5995                     if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_INVLPG))
5996                         break;
5997                     gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5998                     gen_op_invlpg_A0();
5999                     gen_jmp_im(s->pc - s->cs_base);
6000                     gen_eob(s);
6001                 }
6002             }
6003             break;
6004         default:
6005             goto illegal_op;
6006         }
6007         break;
6008     case 0x108: /* invd */
6009     case 0x109: /* wbinvd */
6010         if (s->cpl != 0) {
6011             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6012         } else {
6013             if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_INVD))
6014                 break;
6015             /* nothing to do */
6016         }
6017         break;
6018     case 0x63: /* arpl or movslS (x86_64) */
6019 #ifdef TARGET_X86_64
6020         if (CODE64(s)) {
6021             int d_ot;
6022             /* d_ot is the size of destination */
6023             d_ot = dflag + OT_WORD;
6024
6025             modrm = ldub_code(s->pc++);
6026             reg = ((modrm >> 3) & 7) | rex_r;
6027             mod = (modrm >> 6) & 3;
6028             rm = (modrm & 7) | REX_B(s);
6029
6030             if (mod == 3) {
6031                 gen_op_mov_TN_reg[OT_LONG][0][rm]();
6032                 /* sign extend */
6033                 if (d_ot == OT_QUAD)
6034                     gen_op_movslq_T0_T0();
6035                 gen_op_mov_reg_T0[d_ot][reg]();
6036             } else {
6037                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
6038                 if (d_ot == OT_QUAD) {
6039                     gen_op_lds_T0_A0[OT_LONG + s->mem_index]();
6040                 } else {
6041                     gen_op_ld_T0_A0[OT_LONG + s->mem_index]();
6042                 }
6043                 gen_op_mov_reg_T0[d_ot][reg]();
6044             }
6045         } else
6046 #endif
6047         {
6048             if (!s->pe || s->vm86)
6049                 goto illegal_op;
6050             ot = dflag ? OT_LONG : OT_WORD;
6051             modrm = ldub_code(s->pc++);
6052             reg = (modrm >> 3) & 7;
6053             mod = (modrm >> 6) & 3;
6054             rm = modrm & 7;
6055             if (mod != 3) {
6056                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
6057                 gen_op_ld_T0_A0[ot + s->mem_index]();
6058             } else {
6059                 gen_op_mov_TN_reg[ot][0][rm]();
6060             }
6061             if (s->cc_op != CC_OP_DYNAMIC)
6062                 gen_op_set_cc_op(s->cc_op);
6063             gen_op_arpl();
6064             s->cc_op = CC_OP_EFLAGS;
6065             if (mod != 3) {
6066                 gen_op_st_T0_A0[ot + s->mem_index]();
6067             } else {
6068                 gen_op_mov_reg_T0[ot][rm]();
6069             }
6070             gen_op_arpl_update();
6071         }
6072         break;
6073     case 0x102: /* lar */
6074     case 0x103: /* lsl */
6075         if (!s->pe || s->vm86)
6076             goto illegal_op;
6077         ot = dflag ? OT_LONG : OT_WORD;
6078         modrm = ldub_code(s->pc++);
6079         reg = ((modrm >> 3) & 7) | rex_r;
6080         gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
6081         gen_op_mov_TN_reg[ot][1][reg]();
6082         if (s->cc_op != CC_OP_DYNAMIC)
6083             gen_op_set_cc_op(s->cc_op);
6084         if (b == 0x102)
6085             gen_op_lar();
6086         else
6087             gen_op_lsl();
6088         s->cc_op = CC_OP_EFLAGS;
6089         gen_op_mov_reg_T1[ot][reg]();
6090         break;
6091     case 0x118:
6092         modrm = ldub_code(s->pc++);
6093         mod = (modrm >> 6) & 3;
6094         op = (modrm >> 3) & 7;
6095         switch(op) {
6096         case 0: /* prefetchnta */
6097         case 1: /* prefetchnt0 */
6098         case 2: /* prefetchnt0 */
6099         case 3: /* prefetchnt0 */
6100             if (mod == 3)
6101                 goto illegal_op;
6102             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
6103             /* nothing more to do */
6104             break;
6105         default: /* nop (multi byte) */
6106             gen_nop_modrm(s, modrm);
6107             break;
6108         }
6109         break;
6110     case 0x119 ... 0x11f: /* nop (multi byte) */
6111         modrm = ldub_code(s->pc++);
6112         gen_nop_modrm(s, modrm);
6113         break;
6114     case 0x120: /* mov reg, crN */
6115     case 0x122: /* mov crN, reg */
6116         if (s->cpl != 0) {
6117             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6118         } else {
6119             modrm = ldub_code(s->pc++);
6120             if ((modrm & 0xc0) != 0xc0)
6121                 goto illegal_op;
6122             rm = (modrm & 7) | REX_B(s);
6123             reg = ((modrm >> 3) & 7) | rex_r;
6124             if (CODE64(s))
6125                 ot = OT_QUAD;
6126             else
6127                 ot = OT_LONG;
6128             switch(reg) {
6129             case 0:
6130             case 2:
6131             case 3:
6132             case 4:
6133             case 8:
6134                 if (b & 2) {
6135                     gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_CR0 + reg);
6136                     gen_op_mov_TN_reg[ot][0][rm]();
6137                     gen_op_movl_crN_T0(reg);
6138                     gen_jmp_im(s->pc - s->cs_base);
6139                     gen_eob(s);
6140                 } else {
6141                     gen_svm_check_intercept(s, pc_start, SVM_EXIT_READ_CR0 + reg);
6142 #if !defined(CONFIG_USER_ONLY)
6143                     if (reg == 8)
6144                         gen_op_movtl_T0_cr8();
6145                     else
6146 #endif
6147                         gen_op_movtl_T0_env(offsetof(CPUX86State,cr[reg]));
6148                     gen_op_mov_reg_T0[ot][rm]();
6149                 }
6150                 break;
6151             default:
6152                 goto illegal_op;
6153             }
6154         }
6155         break;
6156     case 0x121: /* mov reg, drN */
6157     case 0x123: /* mov drN, reg */
6158         if (s->cpl != 0) {
6159             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6160         } else {
6161             modrm = ldub_code(s->pc++);
6162             if ((modrm & 0xc0) != 0xc0)
6163                 goto illegal_op;
6164             rm = (modrm & 7) | REX_B(s);
6165             reg = ((modrm >> 3) & 7) | rex_r;
6166             if (CODE64(s))
6167                 ot = OT_QUAD;
6168             else
6169                 ot = OT_LONG;
6170             /* XXX: do it dynamically with CR4.DE bit */
6171             if (reg == 4 || reg == 5 || reg >= 8)
6172                 goto illegal_op;
6173             if (b & 2) {
6174                 gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_DR0 + reg);
6175                 gen_op_mov_TN_reg[ot][0][rm]();
6176                 gen_op_movl_drN_T0(reg);
6177                 gen_jmp_im(s->pc - s->cs_base);
6178                 gen_eob(s);
6179             } else {
6180                 gen_svm_check_intercept(s, pc_start, SVM_EXIT_READ_DR0 + reg);
6181                 gen_op_movtl_T0_env(offsetof(CPUX86State,dr[reg]));
6182                 gen_op_mov_reg_T0[ot][rm]();
6183             }
6184         }
6185         break;
6186     case 0x106: /* clts */
6187         if (s->cpl != 0) {
6188             gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6189         } else {
6190             gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_CR0);
6191             gen_op_clts();
6192             /* abort block because static cpu state changed */
6193             gen_jmp_im(s->pc - s->cs_base);
6194             gen_eob(s);
6195         }
6196         break;
6197     /* MMX/SSE/SSE2/PNI support */
6198     case 0x1c3: /* MOVNTI reg, mem */
6199         if (!(s->cpuid_features & CPUID_SSE2))
6200             goto illegal_op;
6201         ot = s->dflag == 2 ? OT_QUAD : OT_LONG;
6202         modrm = ldub_code(s->pc++);
6203         mod = (modrm >> 6) & 3;
6204         if (mod == 3)
6205             goto illegal_op;
6206         reg = ((modrm >> 3) & 7) | rex_r;
6207         /* generate a generic store */
6208         gen_ldst_modrm(s, modrm, ot, reg, 1);
6209         break;
6210     case 0x1ae:
6211         modrm = ldub_code(s->pc++);
6212         mod = (modrm >> 6) & 3;
6213         op = (modrm >> 3) & 7;
6214         switch(op) {
6215         case 0: /* fxsave */
6216             if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) ||
6217                 (s->flags & HF_EM_MASK))
6218                 goto illegal_op;
6219             if (s->flags & HF_TS_MASK) {
6220                 gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
6221                 break;
6222             }
6223             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
6224             gen_op_fxsave_A0((s->dflag == 2));
6225             break;
6226         case 1: /* fxrstor */
6227             if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) ||
6228                 (s->flags & HF_EM_MASK))
6229                 goto illegal_op;
6230             if (s->flags & HF_TS_MASK) {
6231                 gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
6232                 break;
6233             }
6234             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
6235             gen_op_fxrstor_A0((s->dflag == 2));
6236             break;
6237         case 2: /* ldmxcsr */
6238         case 3: /* stmxcsr */
6239             if (s->flags & HF_TS_MASK) {
6240                 gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
6241                 break;
6242             }
6243             if ((s->flags & HF_EM_MASK) || !(s->flags & HF_OSFXSR_MASK) ||
6244                 mod == 3)
6245                 goto illegal_op;
6246             gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
6247             if (op == 2) {
6248                 gen_op_ld_T0_A0[OT_LONG + s->mem_index]();
6249                 gen_op_movl_env_T0(offsetof(CPUX86State, mxcsr));
6250             } else {
6251                 gen_op_movl_T0_env(offsetof(CPUX86State, mxcsr));
6252                 gen_op_st_T0_A0[OT_LONG + s->mem_index]();
6253             }
6254             break;
6255         case 5: /* lfence */
6256         case 6: /* mfence */
6257             if ((modrm & 0xc7) != 0xc0 || !(s->cpuid_features & CPUID_SSE))
6258                 goto illegal_op;
6259             break;
6260         case 7: /* sfence / clflush */
6261             if ((modrm & 0xc7) == 0xc0) {
6262                 /* sfence */
6263                 if (!(s->cpuid_features & CPUID_SSE))
6264                     goto illegal_op;
6265             } else {
6266                 /* clflush */
6267                 if (!(s->cpuid_features & CPUID_CLFLUSH))
6268                     goto illegal_op;
6269                 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
6270             }
6271             break;
6272         default:
6273             goto illegal_op;
6274         }
6275         break;
6276     case 0x10d: /* prefetch */
6277         modrm = ldub_code(s->pc++);
6278         gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
6279         /* ignore for now */
6280         break;
6281     case 0x1aa: /* rsm */
6282         if (gen_svm_check_intercept(s, pc_start, SVM_EXIT_RSM))
6283             break;
6284         if (!(s->flags & HF_SMM_MASK))
6285             goto illegal_op;
6286         if (s->cc_op != CC_OP_DYNAMIC) {
6287             gen_op_set_cc_op(s->cc_op);
6288             s->cc_op = CC_OP_DYNAMIC;
6289         }
6290         gen_jmp_im(s->pc - s->cs_base);
6291         gen_op_rsm();
6292         gen_eob(s);
6293         break;
6294     case 0x110 ... 0x117:
6295     case 0x128 ... 0x12f:
6296     case 0x150 ... 0x177:
6297     case 0x17c ... 0x17f:
6298     case 0x1c2:
6299     case 0x1c4 ... 0x1c6:
6300     case 0x1d0 ... 0x1fe:
6301         gen_sse(s, b, pc_start, rex_r);
6302         break;
6303     default:
6304         goto illegal_op;
6305     }
6306     /* lock generation */
6307     if (s->prefix & PREFIX_LOCK)
6308         gen_op_unlock();
6309     return s->pc;
6310  illegal_op:
6311     if (s->prefix & PREFIX_LOCK)
6312         gen_op_unlock();
6313     /* XXX: ensure that no lock was generated */
6314     gen_exception(s, EXCP06_ILLOP, pc_start - s->cs_base);
6315     return s->pc;
6316 }
6317
6318 #define CC_OSZAPC (CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C)
6319 #define CC_OSZAP (CC_O | CC_S | CC_Z | CC_A | CC_P)
6320
6321 /* flags read by an operation */
6322 static uint16_t opc_read_flags[NB_OPS] = {
6323     [INDEX_op_aas] = CC_A,
6324     [INDEX_op_aaa] = CC_A,
6325     [INDEX_op_das] = CC_A | CC_C,
6326     [INDEX_op_daa] = CC_A | CC_C,
6327
6328     /* subtle: due to the incl/decl implementation, C is used */
6329     [INDEX_op_update_inc_cc] = CC_C,
6330
6331     [INDEX_op_into] = CC_O,
6332
6333     [INDEX_op_jb_subb] = CC_C,
6334     [INDEX_op_jb_subw] = CC_C,
6335     [INDEX_op_jb_subl] = CC_C,
6336
6337     [INDEX_op_jz_subb] = CC_Z,
6338     [INDEX_op_jz_subw] = CC_Z,
6339     [INDEX_op_jz_subl] = CC_Z,
6340
6341     [INDEX_op_jbe_subb] = CC_Z | CC_C,
6342     [INDEX_op_jbe_subw] = CC_Z | CC_C,
6343     [INDEX_op_jbe_subl] = CC_Z | CC_C,
6344
6345     [INDEX_op_js_subb] = CC_S,
6346     [INDEX_op_js_subw] = CC_S,
6347     [INDEX_op_js_subl] = CC_S,
6348
6349     [INDEX_op_jl_subb] = CC_O | CC_S,
6350     [INDEX_op_jl_subw] = CC_O | CC_S,
6351     [INDEX_op_jl_subl] = CC_O | CC_S,
6352
6353     [INDEX_op_jle_subb] = CC_O | CC_S | CC_Z,
6354     [INDEX_op_jle_subw] = CC_O | CC_S | CC_Z,
6355     [INDEX_op_jle_subl] = CC_O | CC_S | CC_Z,
6356
6357     [INDEX_op_loopnzw] = CC_Z,
6358     [INDEX_op_loopnzl] = CC_Z,
6359     [INDEX_op_loopzw] = CC_Z,
6360     [INDEX_op_loopzl] = CC_Z,
6361
6362     [INDEX_op_seto_T0_cc] = CC_O,
6363     [INDEX_op_setb_T0_cc] = CC_C,
6364     [INDEX_op_setz_T0_cc] = CC_Z,
6365     [INDEX_op_setbe_T0_cc] = CC_Z | CC_C,
6366     [INDEX_op_sets_T0_cc] = CC_S,
6367     [INDEX_op_setp_T0_cc] = CC_P,
6368     [INDEX_op_setl_T0_cc] = CC_O | CC_S,
6369     [INDEX_op_setle_T0_cc] = CC_O | CC_S | CC_Z,
6370
6371     [INDEX_op_setb_T0_subb] = CC_C,
6372     [INDEX_op_setb_T0_subw] = CC_C,
6373     [INDEX_op_setb_T0_subl] = CC_C,
6374
6375     [INDEX_op_setz_T0_subb] = CC_Z,
6376     [INDEX_op_setz_T0_subw] = CC_Z,
6377     [INDEX_op_setz_T0_subl] = CC_Z,
6378
6379     [INDEX_op_setbe_T0_subb] = CC_Z | CC_C,
6380     [INDEX_op_setbe_T0_subw] = CC_Z | CC_C,
6381     [INDEX_op_setbe_T0_subl] = CC_Z | CC_C,
6382
6383     [INDEX_op_sets_T0_subb] = CC_S,
6384     [INDEX_op_sets_T0_subw] = CC_S,
6385     [INDEX_op_sets_T0_subl] = CC_S,
6386
6387     [INDEX_op_setl_T0_subb] = CC_O | CC_S,
6388     [INDEX_op_setl_T0_subw] = CC_O | CC_S,
6389     [INDEX_op_setl_T0_subl] = CC_O | CC_S,
6390
6391     [INDEX_op_setle_T0_subb] = CC_O | CC_S | CC_Z,
6392     [INDEX_op_setle_T0_subw] = CC_O | CC_S | CC_Z,
6393     [INDEX_op_setle_T0_subl] = CC_O | CC_S | CC_Z,
6394
6395     [INDEX_op_movl_T0_eflags] = CC_OSZAPC,
6396     [INDEX_op_cmc] = CC_C,
6397     [INDEX_op_salc] = CC_C,
6398
6399     /* needed for correct flag optimisation before string ops */
6400     [INDEX_op_jnz_ecxw] = CC_OSZAPC,
6401     [INDEX_op_jnz_ecxl] = CC_OSZAPC,
6402     [INDEX_op_jz_ecxw] = CC_OSZAPC,
6403     [INDEX_op_jz_ecxl] = CC_OSZAPC,
6404
6405 #ifdef TARGET_X86_64
6406     [INDEX_op_jb_subq] = CC_C,
6407     [INDEX_op_jz_subq] = CC_Z,
6408     [INDEX_op_jbe_subq] = CC_Z | CC_C,
6409     [INDEX_op_js_subq] = CC_S,
6410     [INDEX_op_jl_subq] = CC_O | CC_S,
6411     [INDEX_op_jle_subq] = CC_O | CC_S | CC_Z,
6412
6413     [INDEX_op_loopnzq] = CC_Z,
6414     [INDEX_op_loopzq] = CC_Z,
6415
6416     [INDEX_op_setb_T0_subq] = CC_C,
6417     [INDEX_op_setz_T0_subq] = CC_Z,
6418     [INDEX_op_setbe_T0_subq] = CC_Z | CC_C,
6419     [INDEX_op_sets_T0_subq] = CC_S,
6420     [INDEX_op_setl_T0_subq] = CC_O | CC_S,
6421     [INDEX_op_setle_T0_subq] = CC_O | CC_S | CC_Z,
6422
6423     [INDEX_op_jnz_ecxq] = CC_OSZAPC,
6424     [INDEX_op_jz_ecxq] = CC_OSZAPC,
6425 #endif
6426
6427 #define DEF_READF(SUFFIX)\
6428     [INDEX_op_adcb ## SUFFIX ## _T0_T1_cc] = CC_C,\
6429     [INDEX_op_adcw ## SUFFIX ## _T0_T1_cc] = CC_C,\
6430     [INDEX_op_adcl ## SUFFIX ## _T0_T1_cc] = CC_C,\
6431     X86_64_DEF([INDEX_op_adcq ## SUFFIX ## _T0_T1_cc] = CC_C,)\
6432     [INDEX_op_sbbb ## SUFFIX ## _T0_T1_cc] = CC_C,\
6433     [INDEX_op_sbbw ## SUFFIX ## _T0_T1_cc] = CC_C,\
6434     [INDEX_op_sbbl ## SUFFIX ## _T0_T1_cc] = CC_C,\
6435     X86_64_DEF([INDEX_op_sbbq ## SUFFIX ## _T0_T1_cc] = CC_C,)\
6436 \
6437     [INDEX_op_rclb ## SUFFIX ## _T0_T1_cc] = CC_C,\
6438     [INDEX_op_rclw ## SUFFIX ## _T0_T1_cc] = CC_C,\
6439     [INDEX_op_rcll ## SUFFIX ## _T0_T1_cc] = CC_C,\
6440     X86_64_DEF([INDEX_op_rclq ## SUFFIX ## _T0_T1_cc] = CC_C,)\
6441     [INDEX_op_rcrb ## SUFFIX ## _T0_T1_cc] = CC_C,\
6442     [INDEX_op_rcrw ## SUFFIX ## _T0_T1_cc] = CC_C,\
6443     [INDEX_op_rcrl ## SUFFIX ## _T0_T1_cc] = CC_C,\
6444     X86_64_DEF([INDEX_op_rcrq ## SUFFIX ## _T0_T1_cc] = CC_C,)
6445
6446     DEF_READF( )
6447     DEF_READF(_raw)
6448 #ifndef CONFIG_USER_ONLY
6449     DEF_READF(_kernel)
6450     DEF_READF(_user)
6451 #endif
6452 };
6453
6454 /* flags written by an operation */
6455 static uint16_t opc_write_flags[NB_OPS] = {
6456     [INDEX_op_update2_cc] = CC_OSZAPC,
6457     [INDEX_op_update1_cc] = CC_OSZAPC,
6458     [INDEX_op_cmpl_T0_T1_cc] = CC_OSZAPC,
6459     [INDEX_op_update_neg_cc] = CC_OSZAPC,
6460     /* subtle: due to the incl/decl implementation, C is used */
6461     [INDEX_op_update_inc_cc] = CC_OSZAPC,
6462     [INDEX_op_testl_T0_T1_cc] = CC_OSZAPC,
6463
6464     [INDEX_op_mulb_AL_T0] = CC_OSZAPC,
6465     [INDEX_op_mulw_AX_T0] = CC_OSZAPC,
6466     [INDEX_op_mull_EAX_T0] = CC_OSZAPC,
6467     X86_64_DEF([INDEX_op_mulq_EAX_T0] = CC_OSZAPC,)
6468     [INDEX_op_imulb_AL_T0] = CC_OSZAPC,
6469     [INDEX_op_imulw_AX_T0] = CC_OSZAPC,
6470     [INDEX_op_imull_EAX_T0] = CC_OSZAPC,
6471     X86_64_DEF([INDEX_op_imulq_EAX_T0] = CC_OSZAPC,)
6472     [INDEX_op_imulw_T0_T1] = CC_OSZAPC,
6473     [INDEX_op_imull_T0_T1] = CC_OSZAPC,
6474     X86_64_DEF([INDEX_op_imulq_T0_T1] = CC_OSZAPC,)
6475
6476     /* sse */
6477     [INDEX_op_ucomiss] = CC_OSZAPC,
6478     [INDEX_op_ucomisd] = CC_OSZAPC,
6479     [INDEX_op_comiss] = CC_OSZAPC,
6480     [INDEX_op_comisd] = CC_OSZAPC,
6481
6482     /* bcd */
6483     [INDEX_op_aam] = CC_OSZAPC,
6484     [INDEX_op_aad] = CC_OSZAPC,
6485     [INDEX_op_aas] = CC_OSZAPC,
6486     [INDEX_op_aaa] = CC_OSZAPC,
6487     [INDEX_op_das] = CC_OSZAPC,
6488     [INDEX_op_daa] = CC_OSZAPC,
6489
6490     [INDEX_op_movb_eflags_T0] = CC_S | CC_Z | CC_A | CC_P | CC_C,
6491     [INDEX_op_movw_eflags_T0] = CC_OSZAPC,
6492     [INDEX_op_movl_eflags_T0] = CC_OSZAPC,
6493     [INDEX_op_movw_eflags_T0_io] = CC_OSZAPC,
6494     [INDEX_op_movl_eflags_T0_io] = CC_OSZAPC,
6495     [INDEX_op_movw_eflags_T0_cpl0] = CC_OSZAPC,
6496     [INDEX_op_movl_eflags_T0_cpl0] = CC_OSZAPC,
6497     [INDEX_op_clc] = CC_C,
6498     [INDEX_op_stc] = CC_C,
6499     [INDEX_op_cmc] = CC_C,
6500
6501     [INDEX_op_btw_T0_T1_cc] = CC_OSZAPC,
6502     [INDEX_op_btl_T0_T1_cc] = CC_OSZAPC,
6503     X86_64_DEF([INDEX_op_btq_T0_T1_cc] = CC_OSZAPC,)
6504     [INDEX_op_btsw_T0_T1_cc] = CC_OSZAPC,
6505     [INDEX_op_btsl_T0_T1_cc] = CC_OSZAPC,
6506     X86_64_DEF([INDEX_op_btsq_T0_T1_cc] = CC_OSZAPC,)
6507     [INDEX_op_btrw_T0_T1_cc] = CC_OSZAPC,
6508     [INDEX_op_btrl_T0_T1_cc] = CC_OSZAPC,
6509     X86_64_DEF([INDEX_op_btrq_T0_T1_cc] = CC_OSZAPC,)
6510     [INDEX_op_btcw_T0_T1_cc] = CC_OSZAPC,
6511     [INDEX_op_btcl_T0_T1_cc] = CC_OSZAPC,
6512     X86_64_DEF([INDEX_op_btcq_T0_T1_cc] = CC_OSZAPC,)
6513
6514     [INDEX_op_bsfw_T0_cc] = CC_OSZAPC,
6515     [INDEX_op_bsfl_T0_cc] = CC_OSZAPC,
6516     X86_64_DEF([INDEX_op_bsfq_T0_cc] = CC_OSZAPC,)
6517     [INDEX_op_bsrw_T0_cc] = CC_OSZAPC,
6518     [INDEX_op_bsrl_T0_cc] = CC_OSZAPC,
6519     X86_64_DEF([INDEX_op_bsrq_T0_cc] = CC_OSZAPC,)
6520
6521     [INDEX_op_cmpxchgb_T0_T1_EAX_cc] = CC_OSZAPC,
6522     [INDEX_op_cmpxchgw_T0_T1_EAX_cc] = CC_OSZAPC,
6523     [INDEX_op_cmpxchgl_T0_T1_EAX_cc] = CC_OSZAPC,
6524     X86_64_DEF([INDEX_op_cmpxchgq_T0_T1_EAX_cc] = CC_OSZAPC,)
6525
6526     [INDEX_op_cmpxchg8b] = CC_Z,
6527     [INDEX_op_lar] = CC_Z,
6528     [INDEX_op_lsl] = CC_Z,
6529     [INDEX_op_verr] = CC_Z,
6530     [INDEX_op_verw] = CC_Z,
6531     [INDEX_op_fcomi_ST0_FT0] = CC_Z | CC_P | CC_C,
6532     [INDEX_op_fucomi_ST0_FT0] = CC_Z | CC_P | CC_C,
6533
6534 #define DEF_WRITEF(SUFFIX)\
6535     [INDEX_op_adcb ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,\
6536     [INDEX_op_adcw ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,\
6537     [INDEX_op_adcl ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,\
6538     X86_64_DEF([INDEX_op_adcq ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,)\
6539     [INDEX_op_sbbb ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,\
6540     [INDEX_op_sbbw ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,\
6541     [INDEX_op_sbbl ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,\
6542     X86_64_DEF([INDEX_op_sbbq ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,)\
6543 \
6544     [INDEX_op_rolb ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,\
6545     [INDEX_op_rolw ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,\
6546     [INDEX_op_roll ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,\
6547     X86_64_DEF([INDEX_op_rolq ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,)\
6548     [INDEX_op_rorb ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,\
6549     [INDEX_op_rorw ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,\
6550     [INDEX_op_rorl ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,\
6551     X86_64_DEF([INDEX_op_rorq ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,)\
6552 \
6553     [INDEX_op_rclb ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,\
6554     [INDEX_op_rclw ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,\
6555     [INDEX_op_rcll ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,\
6556     X86_64_DEF([INDEX_op_rclq ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,)\
6557     [INDEX_op_rcrb ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,\
6558     [INDEX_op_rcrw ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,\
6559     [INDEX_op_rcrl ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,\
6560     X86_64_DEF([INDEX_op_rcrq ## SUFFIX ## _T0_T1_cc] = CC_O | CC_C,)\
6561 \
6562     [INDEX_op_shlb ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,\
6563     [INDEX_op_shlw ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,\
6564     [INDEX_op_shll ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,\
6565     X86_64_DEF([INDEX_op_shlq ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,)\
6566 \
6567     [INDEX_op_shrb ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,\
6568     [INDEX_op_shrw ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,\
6569     [INDEX_op_shrl ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,\
6570     X86_64_DEF([INDEX_op_shrq ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,)\
6571 \
6572     [INDEX_op_sarb ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,\
6573     [INDEX_op_sarw ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,\
6574     [INDEX_op_sarl ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,\
6575     X86_64_DEF([INDEX_op_sarq ## SUFFIX ## _T0_T1_cc] = CC_OSZAPC,)\
6576 \
6577     [INDEX_op_shldw ## SUFFIX ## _T0_T1_ECX_cc] = CC_OSZAPC,\
6578     [INDEX_op_shldl ## SUFFIX ## _T0_T1_ECX_cc] = CC_OSZAPC,\
6579     X86_64_DEF([INDEX_op_shldq ## SUFFIX ## _T0_T1_ECX_cc] = CC_OSZAPC,)\
6580     [INDEX_op_shldw ## SUFFIX ## _T0_T1_im_cc] = CC_OSZAPC,\
6581     [INDEX_op_shldl ## SUFFIX ## _T0_T1_im_cc] = CC_OSZAPC,\
6582     X86_64_DEF([INDEX_op_shldq ## SUFFIX ## _T0_T1_im_cc] = CC_OSZAPC,)\
6583 \
6584     [INDEX_op_shrdw ## SUFFIX ## _T0_T1_ECX_cc] = CC_OSZAPC,\
6585     [INDEX_op_shrdl ## SUFFIX ## _T0_T1_ECX_cc] = CC_OSZAPC,\
6586     X86_64_DEF([INDEX_op_shrdq ## SUFFIX ## _T0_T1_ECX_cc] = CC_OSZAPC,)\
6587     [INDEX_op_shrdw ## SUFFIX ## _T0_T1_im_cc] = CC_OSZAPC,\
6588     [INDEX_op_shrdl ## SUFFIX ## _T0_T1_im_cc] = CC_OSZAPC,\
6589     X86_64_DEF([INDEX_op_shrdq ## SUFFIX ## _T0_T1_im_cc] = CC_OSZAPC,)\
6590 \
6591     [INDEX_op_cmpxchgb ## SUFFIX ## _T0_T1_EAX_cc] = CC_OSZAPC,\
6592     [INDEX_op_cmpxchgw ## SUFFIX ## _T0_T1_EAX_cc] = CC_OSZAPC,\
6593     [INDEX_op_cmpxchgl ## SUFFIX ## _T0_T1_EAX_cc] = CC_OSZAPC,\
6594     X86_64_DEF([INDEX_op_cmpxchgq ## SUFFIX ## _T0_T1_EAX_cc] = CC_OSZAPC,)
6595
6596
6597     DEF_WRITEF( )
6598     DEF_WRITEF(_raw)
6599 #ifndef CONFIG_USER_ONLY
6600     DEF_WRITEF(_kernel)
6601     DEF_WRITEF(_user)
6602 #endif
6603 };
6604
6605 /* simpler form of an operation if no flags need to be generated */
6606 static uint16_t opc_simpler[NB_OPS] = {
6607     [INDEX_op_update2_cc] = INDEX_op_nop,
6608     [INDEX_op_update1_cc] = INDEX_op_nop,
6609     [INDEX_op_update_neg_cc] = INDEX_op_nop,
6610 #if 0
6611     /* broken: CC_OP logic must be rewritten */
6612     [INDEX_op_update_inc_cc] = INDEX_op_nop,
6613 #endif
6614
6615     [INDEX_op_shlb_T0_T1_cc] = INDEX_op_shlb_T0_T1,
6616     [INDEX_op_shlw_T0_T1_cc] = INDEX_op_shlw_T0_T1,
6617     [INDEX_op_shll_T0_T1_cc] = INDEX_op_shll_T0_T1,
6618     X86_64_DEF([INDEX_op_shlq_T0_T1_cc] = INDEX_op_shlq_T0_T1,)
6619
6620     [INDEX_op_shrb_T0_T1_cc] = INDEX_op_shrb_T0_T1,
6621     [INDEX_op_shrw_T0_T1_cc] = INDEX_op_shrw_T0_T1,
6622     [INDEX_op_shrl_T0_T1_cc] = INDEX_op_shrl_T0_T1,
6623     X86_64_DEF([INDEX_op_shrq_T0_T1_cc] = INDEX_op_shrq_T0_T1,)
6624
6625     [INDEX_op_sarb_T0_T1_cc] = INDEX_op_sarb_T0_T1,
6626     [INDEX_op_sarw_T0_T1_cc] = INDEX_op_sarw_T0_T1,
6627     [INDEX_op_sarl_T0_T1_cc] = INDEX_op_sarl_T0_T1,
6628     X86_64_DEF([INDEX_op_sarq_T0_T1_cc] = INDEX_op_sarq_T0_T1,)
6629
6630 #define DEF_SIMPLER(SUFFIX)\
6631     [INDEX_op_rolb ## SUFFIX ## _T0_T1_cc] = INDEX_op_rolb ## SUFFIX ## _T0_T1,\
6632     [INDEX_op_rolw ## SUFFIX ## _T0_T1_cc] = INDEX_op_rolw ## SUFFIX ## _T0_T1,\
6633     [INDEX_op_roll ## SUFFIX ## _T0_T1_cc] = INDEX_op_roll ## SUFFIX ## _T0_T1,\
6634     X86_64_DEF([INDEX_op_rolq ## SUFFIX ## _T0_T1_cc] = INDEX_op_rolq ## SUFFIX ## _T0_T1,)\
6635 \
6636     [INDEX_op_rorb ## SUFFIX ## _T0_T1_cc] = INDEX_op_rorb ## SUFFIX ## _T0_T1,\
6637     [INDEX_op_rorw ## SUFFIX ## _T0_T1_cc] = INDEX_op_rorw ## SUFFIX ## _T0_T1,\
6638     [INDEX_op_rorl ## SUFFIX ## _T0_T1_cc] = INDEX_op_rorl ## SUFFIX ## _T0_T1,\
6639     X86_64_DEF([INDEX_op_rorq ## SUFFIX ## _T0_T1_cc] = INDEX_op_rorq ## SUFFIX ## _T0_T1,)
6640
6641     DEF_SIMPLER( )
6642     DEF_SIMPLER(_raw)
6643 #ifndef CONFIG_USER_ONLY
6644     DEF_SIMPLER(_kernel)
6645     DEF_SIMPLER(_user)
6646 #endif
6647 };
6648
6649 void optimize_flags_init(void)
6650 {
6651     int i;
6652     /* put default values in arrays */
6653     for(i = 0; i < NB_OPS; i++) {
6654         if (opc_simpler[i] == 0)
6655             opc_simpler[i] = i;
6656     }
6657 }
6658
6659 /* CPU flags computation optimization: we move backward thru the
6660    generated code to see which flags are needed. The operation is
6661    modified if suitable */
6662 static void optimize_flags(uint16_t *opc_buf, int opc_buf_len)
6663 {
6664     uint16_t *opc_ptr;
6665     int live_flags, write_flags, op;
6666
6667     opc_ptr = opc_buf + opc_buf_len;
6668     /* live_flags contains the flags needed by the next instructions
6669        in the code. At the end of the block, we consider that all the
6670        flags are live. */
6671     live_flags = CC_OSZAPC;
6672     while (opc_ptr > opc_buf) {
6673         op = *--opc_ptr;
6674         /* if none of the flags written by the instruction is used,
6675            then we can try to find a simpler instruction */
6676         write_flags = opc_write_flags[op];
6677         if ((live_flags & write_flags) == 0) {
6678             *opc_ptr = opc_simpler[op];
6679         }
6680         /* compute the live flags before the instruction */
6681         live_flags &= ~write_flags;
6682         live_flags |= opc_read_flags[op];
6683     }
6684 }
6685
6686 /* generate intermediate code in gen_opc_buf and gen_opparam_buf for
6687    basic block 'tb'. If search_pc is TRUE, also generate PC
6688    information for each intermediate instruction. */
6689 static inline int gen_intermediate_code_internal(CPUState *env,
6690                                                  TranslationBlock *tb,
6691                                                  int search_pc)
6692 {
6693     DisasContext dc1, *dc = &dc1;
6694     target_ulong pc_ptr;
6695     uint16_t *gen_opc_end;
6696     int j, lj, cflags;
6697     uint64_t flags;
6698     target_ulong pc_start;
6699     target_ulong cs_base;
6700
6701     /* generate intermediate code */
6702     pc_start = tb->pc;
6703     cs_base = tb->cs_base;
6704     flags = tb->flags;
6705     cflags = tb->cflags;
6706
6707     dc->pe = (flags >> HF_PE_SHIFT) & 1;
6708     dc->code32 = (flags >> HF_CS32_SHIFT) & 1;
6709     dc->ss32 = (flags >> HF_SS32_SHIFT) & 1;
6710     dc->addseg = (flags >> HF_ADDSEG_SHIFT) & 1;
6711     dc->f_st = 0;
6712     dc->vm86 = (flags >> VM_SHIFT) & 1;
6713     dc->cpl = (flags >> HF_CPL_SHIFT) & 3;
6714     dc->iopl = (flags >> IOPL_SHIFT) & 3;
6715     dc->tf = (flags >> TF_SHIFT) & 1;
6716     dc->singlestep_enabled = env->singlestep_enabled;
6717     dc->cc_op = CC_OP_DYNAMIC;
6718     dc->cs_base = cs_base;
6719     dc->tb = tb;
6720     dc->popl_esp_hack = 0;
6721     /* select memory access functions */
6722     dc->mem_index = 0;
6723     if (flags & HF_SOFTMMU_MASK) {
6724         if (dc->cpl == 3)
6725             dc->mem_index = 2 * 4;
6726         else
6727             dc->mem_index = 1 * 4;
6728     }
6729     dc->cpuid_features = env->cpuid_features;
6730     dc->cpuid_ext_features = env->cpuid_ext_features;
6731 #ifdef TARGET_X86_64
6732     dc->lma = (flags >> HF_LMA_SHIFT) & 1;
6733     dc->code64 = (flags >> HF_CS64_SHIFT) & 1;
6734 #endif
6735     dc->flags = flags;
6736     dc->jmp_opt = !(dc->tf || env->singlestep_enabled ||
6737                     (flags & HF_INHIBIT_IRQ_MASK)
6738 #ifndef CONFIG_SOFTMMU
6739                     || (flags & HF_SOFTMMU_MASK)
6740 #endif
6741                     );
6742 #if 0
6743     /* check addseg logic */
6744     if (!dc->addseg && (dc->vm86 || !dc->pe || !dc->code32))
6745         printf("ERROR addseg\n");
6746 #endif
6747
6748     gen_opc_ptr = gen_opc_buf;
6749     gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
6750     gen_opparam_ptr = gen_opparam_buf;
6751     nb_gen_labels = 0;
6752
6753     dc->is_jmp = DISAS_NEXT;
6754     pc_ptr = pc_start;
6755     lj = -1;
6756
6757     for(;;) {
6758         if (env->nb_breakpoints > 0) {
6759             for(j = 0; j < env->nb_breakpoints; j++) {
6760                 if (env->breakpoints[j] == pc_ptr) {
6761                     gen_debug(dc, pc_ptr - dc->cs_base);
6762                     break;
6763                 }
6764             }
6765         }
6766         if (search_pc) {
6767             j = gen_opc_ptr - gen_opc_buf;
6768             if (lj < j) {
6769                 lj++;
6770                 while (lj < j)
6771                     gen_opc_instr_start[lj++] = 0;
6772             }
6773             gen_opc_pc[lj] = pc_ptr;
6774             gen_opc_cc_op[lj] = dc->cc_op;
6775             gen_opc_instr_start[lj] = 1;
6776         }
6777         pc_ptr = disas_insn(dc, pc_ptr);
6778         /* stop translation if indicated */
6779         if (dc->is_jmp)
6780             break;
6781         /* if single step mode, we generate only one instruction and
6782            generate an exception */
6783         /* if irq were inhibited with HF_INHIBIT_IRQ_MASK, we clear
6784            the flag and abort the translation to give the irqs a
6785            change to be happen */
6786         if (dc->tf || dc->singlestep_enabled ||
6787             (flags & HF_INHIBIT_IRQ_MASK) ||
6788             (cflags & CF_SINGLE_INSN)) {
6789             gen_jmp_im(pc_ptr - dc->cs_base);
6790             gen_eob(dc);
6791             break;
6792         }
6793         /* if too long translation, stop generation too */
6794         if (gen_opc_ptr >= gen_opc_end ||
6795             (pc_ptr - pc_start) >= (TARGET_PAGE_SIZE - 32)) {
6796             gen_jmp_im(pc_ptr - dc->cs_base);
6797             gen_eob(dc);
6798             break;
6799         }
6800     }
6801     *gen_opc_ptr = INDEX_op_end;
6802     /* we don't forget to fill the last values */
6803     if (search_pc) {
6804         j = gen_opc_ptr - gen_opc_buf;
6805         lj++;
6806         while (lj <= j)
6807             gen_opc_instr_start[lj++] = 0;
6808     }
6809
6810 #ifdef DEBUG_DISAS
6811     if (loglevel & CPU_LOG_TB_CPU) {
6812         cpu_dump_state(env, logfile, fprintf, X86_DUMP_CCOP);
6813     }
6814     if (loglevel & CPU_LOG_TB_IN_ASM) {
6815         int disas_flags;
6816         fprintf(logfile, "----------------\n");
6817         fprintf(logfile, "IN: %s\n", lookup_symbol(pc_start));
6818 #ifdef TARGET_X86_64
6819         if (dc->code64)
6820             disas_flags = 2;
6821         else
6822 #endif
6823             disas_flags = !dc->code32;
6824         target_disas(logfile, pc_start, pc_ptr - pc_start, disas_flags);
6825         fprintf(logfile, "\n");
6826         if (loglevel & CPU_LOG_TB_OP) {
6827             fprintf(logfile, "OP:\n");
6828             dump_ops(gen_opc_buf, gen_opparam_buf);
6829             fprintf(logfile, "\n");
6830         }
6831     }
6832 #endif
6833
6834     /* optimize flag computations */
6835     optimize_flags(gen_opc_buf, gen_opc_ptr - gen_opc_buf);
6836
6837 #ifdef DEBUG_DISAS
6838     if (loglevel & CPU_LOG_TB_OP_OPT) {
6839         fprintf(logfile, "AFTER FLAGS OPT:\n");
6840         dump_ops(gen_opc_buf, gen_opparam_buf);
6841         fprintf(logfile, "\n");
6842     }
6843 #endif
6844     if (!search_pc)
6845         tb->size = pc_ptr - pc_start;
6846     return 0;
6847 }
6848
6849 int gen_intermediate_code(CPUState *env, TranslationBlock *tb)
6850 {
6851     return gen_intermediate_code_internal(env, tb, 0);
6852 }
6853
6854 int gen_intermediate_code_pc(CPUState *env, TranslationBlock *tb)
6855 {
6856     return gen_intermediate_code_internal(env, tb, 1);
6857 }
6858