vcs.maemo.org Git - qemu/blob - target-i386/op_helper.c

   1 /*
   2  *  i386 helpers
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA  02110-1301 USA
  19  */
  20 #define CPU_NO_GLOBAL_REGS
  21 #include "exec.h"
  22 #include "exec-all.h"
  23 #include "host-utils.h"
  24
  25 //#define DEBUG_PCALL
  26
  27
  28 #ifdef DEBUG_PCALL
  29 #  define LOG_PCALL(...) qemu_log_mask(CPU_LOG_PCALL, ## __VA_ARGS__)
  30 #  define LOG_PCALL_STATE(env) \
  31           log_cpu_state_mask(CPU_LOG_PCALL, (env), X86_DUMP_CCOP)
  32 #else
  33 #  define LOG_PCALL(...) do { } while (0)
  34 #  define LOG_PCALL_STATE(env) do { } while (0)
  35 #endif
  36
  37
  38 #if 0
  39 #define raise_exception_err(a, b)\
  40 do {\
  41     qemu_log("raise_exception line=%d\n", __LINE__);\
  42     (raise_exception_err)(a, b);\
  43 } while (0)
  44 #endif
  45
  46 static const uint8_t parity_table[256] = {
  47     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  48     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  49     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  50     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  51     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  52     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  53     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  54     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  55     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  56     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  57     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  58     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  59     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  60     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  61     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  62     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  63     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  64     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  65     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  66     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  67     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  68     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  69     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  70     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  71     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  72     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  73     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  74     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  75     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  76     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  77     CC_P, 0, 0, CC_P, 0, CC_P, CC_P, 0,
  78     0, CC_P, CC_P, 0, CC_P, 0, 0, CC_P,
  79 };
  80
  81 /* modulo 17 table */
  82 static const uint8_t rclw_table[32] = {
  83     0, 1, 2, 3, 4, 5, 6, 7,
  84     8, 9,10,11,12,13,14,15,
  85    16, 0, 1, 2, 3, 4, 5, 6,
  86     7, 8, 9,10,11,12,13,14,
  87 };
  88
  89 /* modulo 9 table */
  90 static const uint8_t rclb_table[32] = {
  91     0, 1, 2, 3, 4, 5, 6, 7,
  92     8, 0, 1, 2, 3, 4, 5, 6,
  93     7, 8, 0, 1, 2, 3, 4, 5,
  94     6, 7, 8, 0, 1, 2, 3, 4,
  95 };
  96
  97 static const CPU86_LDouble f15rk[7] =
  98 {
  99     0.00000000000000000000L,
 100     1.00000000000000000000L,
 101     3.14159265358979323851L,  /*pi*/
 102     0.30102999566398119523L,  /*lg2*/
 103     0.69314718055994530943L,  /*ln2*/
 104     1.44269504088896340739L,  /*l2e*/
 105     3.32192809488736234781L,  /*l2t*/
 106 };
 107
 108 /* broken thread support */
 109
 110 static spinlock_t global_cpu_lock = SPIN_LOCK_UNLOCKED;
 111
 112 void helper_lock(void)
 113 {
 114     spin_lock(&global_cpu_lock);
 115 }
 116
 117 void helper_unlock(void)
 118 {
 119     spin_unlock(&global_cpu_lock);
 120 }
 121
 122 void helper_write_eflags(target_ulong t0, uint32_t update_mask)
 123 {
 124     load_eflags(t0, update_mask);
 125 }
 126
 127 target_ulong helper_read_eflags(void)
 128 {
 129     uint32_t eflags;
 130     eflags = helper_cc_compute_all(CC_OP);
 131     eflags |= (DF & DF_MASK);
 132     eflags |= env->eflags & ~(VM_MASK | RF_MASK);
 133     return eflags;
 134 }
 135
 136 /* return non zero if error */
 137 static inline int load_segment(uint32_t *e1_ptr, uint32_t *e2_ptr,
 138                                int selector)
 139 {
 140     SegmentCache *dt;
 141     int index;
 142     target_ulong ptr;
 143
 144     if (selector & 0x4)
 145         dt = &env->ldt;
 146     else
 147         dt = &env->gdt;
 148     index = selector & ~7;
 149     if ((index + 7) > dt->limit)
 150         return -1;
 151     ptr = dt->base + index;
 152     *e1_ptr = ldl_kernel(ptr);
 153     *e2_ptr = ldl_kernel(ptr + 4);
 154     return 0;
 155 }
 156
 157 static inline unsigned int get_seg_limit(uint32_t e1, uint32_t e2)
 158 {
 159     unsigned int limit;
 160     limit = (e1 & 0xffff) | (e2 & 0x000f0000);
 161     if (e2 & DESC_G_MASK)
 162         limit = (limit << 12) | 0xfff;
 163     return limit;
 164 }
 165
 166 static inline uint32_t get_seg_base(uint32_t e1, uint32_t e2)
 167 {
 168     return ((e1 >> 16) | ((e2 & 0xff) << 16) | (e2 & 0xff000000));
 169 }
 170
 171 static inline void load_seg_cache_raw_dt(SegmentCache *sc, uint32_t e1, uint32_t e2)
 172 {
 173     sc->base = get_seg_base(e1, e2);
 174     sc->limit = get_seg_limit(e1, e2);
 175     sc->flags = e2;
 176 }
 177
 178 /* init the segment cache in vm86 mode. */
 179 static inline void load_seg_vm(int seg, int selector)
 180 {
 181     selector &= 0xffff;
 182     cpu_x86_load_seg_cache(env, seg, selector,
 183                            (selector << 4), 0xffff, 0);
 184 }
 185
 186 static inline void get_ss_esp_from_tss(uint32_t *ss_ptr,
 187                                        uint32_t *esp_ptr, int dpl)
 188 {
 189     int type, index, shift;
 190
 191 #if 0
 192     {
 193         int i;
 194         printf("TR: base=%p limit=%x\n", env->tr.base, env->tr.limit);
 195         for(i=0;i<env->tr.limit;i++) {
 196             printf("%02x ", env->tr.base[i]);
 197             if ((i & 7) == 7) printf("\n");
 198         }
 199         printf("\n");
 200     }
 201 #endif
 202
 203     if (!(env->tr.flags & DESC_P_MASK))
 204         cpu_abort(env, "invalid tss");
 205     type = (env->tr.flags >> DESC_TYPE_SHIFT) & 0xf;
 206     if ((type & 7) != 1)
 207         cpu_abort(env, "invalid tss type");
 208     shift = type >> 3;
 209     index = (dpl * 4 + 2) << shift;
 210     if (index + (4 << shift) - 1 > env->tr.limit)
 211         raise_exception_err(EXCP0A_TSS, env->tr.selector & 0xfffc);
 212     if (shift == 0) {
 213         *esp_ptr = lduw_kernel(env->tr.base + index);
 214         *ss_ptr = lduw_kernel(env->tr.base + index + 2);
 215     } else {
 216         *esp_ptr = ldl_kernel(env->tr.base + index);
 217         *ss_ptr = lduw_kernel(env->tr.base + index + 4);
 218     }
 219 }
 220
 221 /* XXX: merge with load_seg() */
 222 static void tss_load_seg(int seg_reg, int selector)
 223 {
 224     uint32_t e1, e2;
 225     int rpl, dpl, cpl;
 226
 227     if ((selector & 0xfffc) != 0) {
 228         if (load_segment(&e1, &e2, selector) != 0)
 229             raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
 230         if (!(e2 & DESC_S_MASK))
 231             raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
 232         rpl = selector & 3;
 233         dpl = (e2 >> DESC_DPL_SHIFT) & 3;
 234         cpl = env->hflags & HF_CPL_MASK;
 235         if (seg_reg == R_CS) {
 236             if (!(e2 & DESC_CS_MASK))
 237                 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
 238             /* XXX: is it correct ? */
 239             if (dpl != rpl)
 240                 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
 241             if ((e2 & DESC_C_MASK) && dpl > rpl)
 242                 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
 243         } else if (seg_reg == R_SS) {
 244             /* SS must be writable data */
 245             if ((e2 & DESC_CS_MASK) || !(e2 & DESC_W_MASK))
 246                 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
 247             if (dpl != cpl || dpl != rpl)
 248                 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
 249         } else {
 250             /* not readable code */
 251             if ((e2 & DESC_CS_MASK) && !(e2 & DESC_R_MASK))
 252                 raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
 253             /* if data or non conforming code, checks the rights */
 254             if (((e2 >> DESC_TYPE_SHIFT) & 0xf) < 12) {
 255                 if (dpl < cpl || dpl < rpl)
 256                     raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
 257             }
 258         }
 259         if (!(e2 & DESC_P_MASK))
 260             raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
 261         cpu_x86_load_seg_cache(env, seg_reg, selector,
 262                        get_seg_base(e1, e2),
 263                        get_seg_limit(e1, e2),
 264                        e2);
 265     } else {
 266         if (seg_reg == R_SS || seg_reg == R_CS)
 267             raise_exception_err(EXCP0A_TSS, selector & 0xfffc);
 268     }
 269 }
 270
 271 #define SWITCH_TSS_JMP  0
 272 #define SWITCH_TSS_IRET 1
 273 #define SWITCH_TSS_CALL 2
 274
 275 /* XXX: restore CPU state in registers (PowerPC case) */
 276 static void switch_tss(int tss_selector,
 277                        uint32_t e1, uint32_t e2, int source,
 278                        uint32_t next_eip)
 279 {
 280     int tss_limit, tss_limit_max, type, old_tss_limit_max, old_type, v1, v2, i;
 281     target_ulong tss_base;
 282     uint32_t new_regs[8], new_segs[6];
 283     uint32_t new_eflags, new_eip, new_cr3, new_ldt, new_trap;
 284     uint32_t old_eflags, eflags_mask;
 285     SegmentCache *dt;
 286     int index;
 287     target_ulong ptr;
 288
 289     type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
 290     LOG_PCALL("switch_tss: sel=0x%04x type=%d src=%d\n", tss_selector, type, source);
 291
 292     /* if task gate, we read the TSS segment and we load it */
 293     if (type == 5) {
 294         if (!(e2 & DESC_P_MASK))
 295             raise_exception_err(EXCP0B_NOSEG, tss_selector & 0xfffc);
 296         tss_selector = e1 >> 16;
 297         if (tss_selector & 4)
 298             raise_exception_err(EXCP0A_TSS, tss_selector & 0xfffc);
 299         if (load_segment(&e1, &e2, tss_selector) != 0)
 300             raise_exception_err(EXCP0D_GPF, tss_selector & 0xfffc);
 301         if (e2 & DESC_S_MASK)
 302             raise_exception_err(EXCP0D_GPF, tss_selector & 0xfffc);
 303         type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
 304         if ((type & 7) != 1)
 305             raise_exception_err(EXCP0D_GPF, tss_selector & 0xfffc);
 306     }
 307
 308     if (!(e2 & DESC_P_MASK))
 309         raise_exception_err(EXCP0B_NOSEG, tss_selector & 0xfffc);
 310
 311     if (type & 8)
 312         tss_limit_max = 103;
 313     else
 314         tss_limit_max = 43;
 315     tss_limit = get_seg_limit(e1, e2);
 316     tss_base = get_seg_base(e1, e2);
 317     if ((tss_selector & 4) != 0 ||
 318         tss_limit < tss_limit_max)
 319         raise_exception_err(EXCP0A_TSS, tss_selector & 0xfffc);
 320     old_type = (env->tr.flags >> DESC_TYPE_SHIFT) & 0xf;
 321     if (old_type & 8)
 322         old_tss_limit_max = 103;
 323     else
 324         old_tss_limit_max = 43;
 325
 326     /* read all the registers from the new TSS */
 327     if (type & 8) {
 328         /* 32 bit */
 329         new_cr3 = ldl_kernel(tss_base + 0x1c);
 330         new_eip = ldl_kernel(tss_base + 0x20);
 331         new_eflags = ldl_kernel(tss_base + 0x24);
 332         for(i = 0; i < 8; i++)
 333             new_regs[i] = ldl_kernel(tss_base + (0x28 + i * 4));
 334         for(i = 0; i < 6; i++)
 335             new_segs[i] = lduw_kernel(tss_base + (0x48 + i * 4));
 336         new_ldt = lduw_kernel(tss_base + 0x60);
 337         new_trap = ldl_kernel(tss_base + 0x64);
 338     } else {
 339         /* 16 bit */
 340         new_cr3 = 0;
 341         new_eip = lduw_kernel(tss_base + 0x0e);
 342         new_eflags = lduw_kernel(tss_base + 0x10);
 343         for(i = 0; i < 8; i++)
 344             new_regs[i] = lduw_kernel(tss_base + (0x12 + i * 2)) | 0xffff0000;
 345         for(i = 0; i < 4; i++)
 346             new_segs[i] = lduw_kernel(tss_base + (0x22 + i * 4));
 347         new_ldt = lduw_kernel(tss_base + 0x2a);
 348         new_segs[R_FS] = 0;
 349         new_segs[R_GS] = 0;
 350         new_trap = 0;
 351     }
 352
 353     /* NOTE: we must avoid memory exceptions during the task switch,
 354        so we make dummy accesses before */
 355     /* XXX: it can still fail in some cases, so a bigger hack is
 356        necessary to valid the TLB after having done the accesses */
 357
 358     v1 = ldub_kernel(env->tr.base);
 359     v2 = ldub_kernel(env->tr.base + old_tss_limit_max);
 360     stb_kernel(env->tr.base, v1);
 361     stb_kernel(env->tr.base + old_tss_limit_max, v2);
 362
 363     /* clear busy bit (it is restartable) */
 364     if (source == SWITCH_TSS_JMP || source == SWITCH_TSS_IRET) {
 365         target_ulong ptr;
 366         uint32_t e2;
 367         ptr = env->gdt.base + (env->tr.selector & ~7);
 368         e2 = ldl_kernel(ptr + 4);
 369         e2 &= ~DESC_TSS_BUSY_MASK;
 370         stl_kernel(ptr + 4, e2);
 371     }
 372     old_eflags = compute_eflags();
 373     if (source == SWITCH_TSS_IRET)
 374         old_eflags &= ~NT_MASK;
 375
 376     /* save the current state in the old TSS */
 377     if (type & 8) {
 378         /* 32 bit */
 379         stl_kernel(env->tr.base + 0x20, next_eip);
 380         stl_kernel(env->tr.base + 0x24, old_eflags);
 381         stl_kernel(env->tr.base + (0x28 + 0 * 4), EAX);
 382         stl_kernel(env->tr.base + (0x28 + 1 * 4), ECX);
 383         stl_kernel(env->tr.base + (0x28 + 2 * 4), EDX);
 384         stl_kernel(env->tr.base + (0x28 + 3 * 4), EBX);
 385         stl_kernel(env->tr.base + (0x28 + 4 * 4), ESP);
 386         stl_kernel(env->tr.base + (0x28 + 5 * 4), EBP);
 387         stl_kernel(env->tr.base + (0x28 + 6 * 4), ESI);
 388         stl_kernel(env->tr.base + (0x28 + 7 * 4), EDI);
 389         for(i = 0; i < 6; i++)
 390             stw_kernel(env->tr.base + (0x48 + i * 4), env->segs[i].selector);
 391     } else {
 392         /* 16 bit */
 393         stw_kernel(env->tr.base + 0x0e, next_eip);
 394         stw_kernel(env->tr.base + 0x10, old_eflags);
 395         stw_kernel(env->tr.base + (0x12 + 0 * 2), EAX);
 396         stw_kernel(env->tr.base + (0x12 + 1 * 2), ECX);
 397         stw_kernel(env->tr.base + (0x12 + 2 * 2), EDX);
 398         stw_kernel(env->tr.base + (0x12 + 3 * 2), EBX);
 399         stw_kernel(env->tr.base + (0x12 + 4 * 2), ESP);
 400         stw_kernel(env->tr.base + (0x12 + 5 * 2), EBP);
 401         stw_kernel(env->tr.base + (0x12 + 6 * 2), ESI);
 402         stw_kernel(env->tr.base + (0x12 + 7 * 2), EDI);
 403         for(i = 0; i < 4; i++)
 404             stw_kernel(env->tr.base + (0x22 + i * 4), env->segs[i].selector);
 405     }
 406
 407     /* now if an exception occurs, it will occurs in the next task
 408        context */
 409
 410     if (source == SWITCH_TSS_CALL) {
 411         stw_kernel(tss_base, env->tr.selector);
 412         new_eflags |= NT_MASK;
 413     }
 414
 415     /* set busy bit */
 416     if (source == SWITCH_TSS_JMP || source == SWITCH_TSS_CALL) {
 417         target_ulong ptr;
 418         uint32_t e2;
 419         ptr = env->gdt.base + (tss_selector & ~7);
 420         e2 = ldl_kernel(ptr + 4);
 421         e2 |= DESC_TSS_BUSY_MASK;
 422         stl_kernel(ptr + 4, e2);
 423     }
 424
 425     /* set the new CPU state */
 426     /* from this point, any exception which occurs can give problems */
 427     env->cr[0] |= CR0_TS_MASK;
 428     env->hflags |= HF_TS_MASK;
 429     env->tr.selector = tss_selector;
 430     env->tr.base = tss_base;
 431     env->tr.limit = tss_limit;
 432     env->tr.flags = e2 & ~DESC_TSS_BUSY_MASK;
 433
 434     if ((type & 8) && (env->cr[0] & CR0_PG_MASK)) {
 435         cpu_x86_update_cr3(env, new_cr3);
 436     }
 437
 438     /* load all registers without an exception, then reload them with
 439        possible exception */
 440     env->eip = new_eip;
 441     eflags_mask = TF_MASK | AC_MASK | ID_MASK |
 442         IF_MASK | IOPL_MASK | VM_MASK | RF_MASK | NT_MASK;
 443     if (!(type & 8))
 444         eflags_mask &= 0xffff;
 445     load_eflags(new_eflags, eflags_mask);
 446     /* XXX: what to do in 16 bit case ? */
 447     EAX = new_regs[0];
 448     ECX = new_regs[1];
 449     EDX = new_regs[2];
 450     EBX = new_regs[3];
 451     ESP = new_regs[4];
 452     EBP = new_regs[5];
 453     ESI = new_regs[6];
 454     EDI = new_regs[7];
 455     if (new_eflags & VM_MASK) {
 456         for(i = 0; i < 6; i++)
 457             load_seg_vm(i, new_segs[i]);
 458         /* in vm86, CPL is always 3 */
 459         cpu_x86_set_cpl(env, 3);
 460     } else {
 461         /* CPL is set the RPL of CS */
 462         cpu_x86_set_cpl(env, new_segs[R_CS] & 3);
 463         /* first just selectors as the rest may trigger exceptions */
 464         for(i = 0; i < 6; i++)
 465             cpu_x86_load_seg_cache(env, i, new_segs[i], 0, 0, 0);
 466     }
 467
 468     env->ldt.selector = new_ldt & ~4;
 469     env->ldt.base = 0;
 470     env->ldt.limit = 0;
 471     env->ldt.flags = 0;
 472
 473     /* load the LDT */
 474     if (new_ldt & 4)
 475         raise_exception_err(EXCP0A_TSS, new_ldt & 0xfffc);
 476
 477     if ((new_ldt & 0xfffc) != 0) {
 478         dt = &env->gdt;
 479         index = new_ldt & ~7;
 480         if ((index + 7) > dt->limit)
 481             raise_exception_err(EXCP0A_TSS, new_ldt & 0xfffc);
 482         ptr = dt->base + index;
 483         e1 = ldl_kernel(ptr);
 484         e2 = ldl_kernel(ptr + 4);
 485         if ((e2 & DESC_S_MASK) || ((e2 >> DESC_TYPE_SHIFT) & 0xf) != 2)
 486             raise_exception_err(EXCP0A_TSS, new_ldt & 0xfffc);
 487         if (!(e2 & DESC_P_MASK))
 488             raise_exception_err(EXCP0A_TSS, new_ldt & 0xfffc);
 489         load_seg_cache_raw_dt(&env->ldt, e1, e2);
 490     }
 491
 492     /* load the segments */
 493     if (!(new_eflags & VM_MASK)) {
 494         tss_load_seg(R_CS, new_segs[R_CS]);
 495         tss_load_seg(R_SS, new_segs[R_SS]);
 496         tss_load_seg(R_ES, new_segs[R_ES]);
 497         tss_load_seg(R_DS, new_segs[R_DS]);
 498         tss_load_seg(R_FS, new_segs[R_FS]);
 499         tss_load_seg(R_GS, new_segs[R_GS]);
 500     }
 501
 502     /* check that EIP is in the CS segment limits */
 503     if (new_eip > env->segs[R_CS].limit) {
 504         /* XXX: different exception if CALL ? */
 505         raise_exception_err(EXCP0D_GPF, 0);
 506     }
 507
 508 #ifndef CONFIG_USER_ONLY
 509     /* reset local breakpoints */
 510     if (env->dr[7] & 0x55) {
 511         for (i = 0; i < 4; i++) {
 512             if (hw_breakpoint_enabled(env->dr[7], i) == 0x1)
 513                 hw_breakpoint_remove(env, i);
 514         }
 515         env->dr[7] &= ~0x55;
 516     }
 517 #endif
 518 }
 519
 520 /* check if Port I/O is allowed in TSS */
 521 static inline void check_io(int addr, int size)
 522 {
 523     int io_offset, val, mask;
 524
 525     /* TSS must be a valid 32 bit one */
 526     if (!(env->tr.flags & DESC_P_MASK) ||
 527         ((env->tr.flags >> DESC_TYPE_SHIFT) & 0xf) != 9 ||
 528         env->tr.limit < 103)
 529         goto fail;
 530     io_offset = lduw_kernel(env->tr.base + 0x66);
 531     io_offset += (addr >> 3);
 532     /* Note: the check needs two bytes */
 533     if ((io_offset + 1) > env->tr.limit)
 534         goto fail;
 535     val = lduw_kernel(env->tr.base + io_offset);
 536     val >>= (addr & 7);
 537     mask = (1 << size) - 1;
 538     /* all bits must be zero to allow the I/O */
 539     if ((val & mask) != 0) {
 540     fail:
 541         raise_exception_err(EXCP0D_GPF, 0);
 542     }
 543 }
 544
 545 void helper_check_iob(uint32_t t0)
 546 {
 547     check_io(t0, 1);
 548 }
 549
 550 void helper_check_iow(uint32_t t0)
 551 {
 552     check_io(t0, 2);
 553 }
 554
 555 void helper_check_iol(uint32_t t0)
 556 {
 557     check_io(t0, 4);
 558 }
 559
 560 void helper_outb(uint32_t port, uint32_t data)
 561 {
 562     cpu_outb(env, port, data & 0xff);
 563 }
 564
 565 target_ulong helper_inb(uint32_t port)
 566 {
 567     return cpu_inb(env, port);
 568 }
 569
 570 void helper_outw(uint32_t port, uint32_t data)
 571 {
 572     cpu_outw(env, port, data & 0xffff);
 573 }
 574
 575 target_ulong helper_inw(uint32_t port)
 576 {
 577     return cpu_inw(env, port);
 578 }
 579
 580 void helper_outl(uint32_t port, uint32_t data)
 581 {
 582     cpu_outl(env, port, data);
 583 }
 584
 585 target_ulong helper_inl(uint32_t port)
 586 {
 587     return cpu_inl(env, port);
 588 }
 589
 590 static inline unsigned int get_sp_mask(unsigned int e2)
 591 {
 592     if (e2 & DESC_B_MASK)
 593         return 0xffffffff;
 594     else
 595         return 0xffff;
 596 }
 597
 598 #ifdef TARGET_X86_64
 599 #define SET_ESP(val, sp_mask)\
 600 do {\
 601     if ((sp_mask) == 0xffff)\
 602         ESP = (ESP & ~0xffff) | ((val) & 0xffff);\
 603     else if ((sp_mask) == 0xffffffffLL)\
 604         ESP = (uint32_t)(val);\
 605     else\
 606         ESP = (val);\
 607 } while (0)
 608 #else
 609 #define SET_ESP(val, sp_mask) ESP = (ESP & ~(sp_mask)) | ((val) & (sp_mask))
 610 #endif
 611
 612 /* in 64-bit machines, this can overflow. So this segment addition macro
 613  * can be used to trim the value to 32-bit whenever needed */
 614 #define SEG_ADDL(ssp, sp, sp_mask) ((uint32_t)((ssp) + (sp & (sp_mask))))
 615
 616 /* XXX: add a is_user flag to have proper security support */
 617 #define PUSHW(ssp, sp, sp_mask, val)\
 618 {\
 619     sp -= 2;\
 620     stw_kernel((ssp) + (sp & (sp_mask)), (val));\
 621 }
 622
 623 #define PUSHL(ssp, sp, sp_mask, val)\
 624 {\
 625     sp -= 4;\
 626     stl_kernel(SEG_ADDL(ssp, sp, sp_mask), (uint32_t)(val));\
 627 }
 628
 629 #define POPW(ssp, sp, sp_mask, val)\
 630 {\
 631     val = lduw_kernel((ssp) + (sp & (sp_mask)));\
 632     sp += 2;\
 633 }
 634
 635 #define POPL(ssp, sp, sp_mask, val)\
 636 {\
 637     val = (uint32_t)ldl_kernel(SEG_ADDL(ssp, sp, sp_mask));\
 638     sp += 4;\
 639 }
 640
 641 /* protected mode interrupt */
 642 static void do_interrupt_protected(int intno, int is_int, int error_code,
 643                                    unsigned int next_eip, int is_hw)
 644 {
 645     SegmentCache *dt;
 646     target_ulong ptr, ssp;
 647     int type, dpl, selector, ss_dpl, cpl;
 648     int has_error_code, new_stack, shift;
 649     uint32_t e1, e2, offset, ss = 0, esp, ss_e1 = 0, ss_e2 = 0;
 650     uint32_t old_eip, sp_mask;
 651
 652     has_error_code = 0;
 653     if (!is_int && !is_hw) {
 654         switch(intno) {
 655         case 8:
 656         case 10:
 657         case 11:
 658         case 12:
 659         case 13:
 660         case 14:
 661         case 17:
 662             has_error_code = 1;
 663             break;
 664         }
 665     }
 666     if (is_int)
 667         old_eip = next_eip;
 668     else
 669         old_eip = env->eip;
 670
 671     dt = &env->idt;
 672     if (intno * 8 + 7 > dt->limit)
 673         raise_exception_err(EXCP0D_GPF, intno * 8 + 2);
 674     ptr = dt->base + intno * 8;
 675     e1 = ldl_kernel(ptr);
 676     e2 = ldl_kernel(ptr + 4);
 677     /* check gate type */
 678     type = (e2 >> DESC_TYPE_SHIFT) & 0x1f;
 679     switch(type) {
 680     case 5: /* task gate */
 681         /* must do that check here to return the correct error code */
 682         if (!(e2 & DESC_P_MASK))
 683             raise_exception_err(EXCP0B_NOSEG, intno * 8 + 2);
 684         switch_tss(intno * 8, e1, e2, SWITCH_TSS_CALL, old_eip);
 685         if (has_error_code) {
 686             int type;
 687             uint32_t mask;
 688             /* push the error code */
 689             type = (env->tr.flags >> DESC_TYPE_SHIFT) & 0xf;
 690             shift = type >> 3;
 691             if (env->segs[R_SS].flags & DESC_B_MASK)
 692                 mask = 0xffffffff;
 693             else
 694                 mask = 0xffff;
 695             esp = (ESP - (2 << shift)) & mask;
 696             ssp = env->segs[R_SS].base + esp;
 697             if (shift)
 698                 stl_kernel(ssp, error_code);
 699             else
 700                 stw_kernel(ssp, error_code);
 701             SET_ESP(esp, mask);
 702         }
 703         return;
 704     case 6: /* 286 interrupt gate */
 705     case 7: /* 286 trap gate */
 706     case 14: /* 386 interrupt gate */
 707     case 15: /* 386 trap gate */
 708         break;
 709     default:
 710         raise_exception_err(EXCP0D_GPF, intno * 8 + 2);
 711         break;
 712     }
 713     dpl = (e2 >> DESC_DPL_SHIFT) & 3;
 714     cpl = env->hflags & HF_CPL_MASK;
 715     /* check privilege if software int */
 716     if (is_int && dpl < cpl)
 717         raise_exception_err(EXCP0D_GPF, intno * 8 + 2);
 718     /* check valid bit */
 719     if (!(e2 & DESC_P_MASK))
 720         raise_exception_err(EXCP0B_NOSEG, intno * 8 + 2);
 721     selector = e1 >> 16;
 722     offset = (e2 & 0xffff0000) | (e1 & 0x0000ffff);
 723     if ((selector & 0xfffc) == 0)
 724         raise_exception_err(EXCP0D_GPF, 0);
 725
 726     if (load_segment(&e1, &e2, selector) != 0)
 727         raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
 728     if (!(e2 & DESC_S_MASK) || !(e2 & (DESC_CS_MASK)))
 729         raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
 730     dpl = (e2 >> DESC_DPL_SHIFT) & 3;
 731     if (dpl > cpl)
 732         raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
 733     if (!(e2 & DESC_P_MASK))
 734         raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
 735     if (!(e2 & DESC_C_MASK) && dpl < cpl) {
 736         /* to inner privilege */
 737         get_ss_esp_from_tss(&ss, &esp, dpl);
 738         if ((ss & 0xfffc) == 0)
 739             raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
 740         if ((ss & 3) != dpl)
 741             raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
 742         if (load_segment(&ss_e1, &ss_e2, ss) != 0)
 743             raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
 744         ss_dpl = (ss_e2 >> DESC_DPL_SHIFT) & 3;
 745         if (ss_dpl != dpl)
 746             raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
 747         if (!(ss_e2 & DESC_S_MASK) ||
 748             (ss_e2 & DESC_CS_MASK) ||
 749             !(ss_e2 & DESC_W_MASK))
 750             raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
 751         if (!(ss_e2 & DESC_P_MASK))
 752             raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
 753         new_stack = 1;
 754         sp_mask = get_sp_mask(ss_e2);
 755         ssp = get_seg_base(ss_e1, ss_e2);
 756     } else if ((e2 & DESC_C_MASK) || dpl == cpl) {
 757         /* to same privilege */
 758         if (env->eflags & VM_MASK)
 759             raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
 760         new_stack = 0;
 761         sp_mask = get_sp_mask(env->segs[R_SS].flags);
 762         ssp = env->segs[R_SS].base;
 763         esp = ESP;
 764         dpl = cpl;
 765     } else {
 766         raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
 767         new_stack = 0; /* avoid warning */
 768         sp_mask = 0; /* avoid warning */
 769         ssp = 0; /* avoid warning */
 770         esp = 0; /* avoid warning */
 771     }
 772
 773     shift = type >> 3;
 774
 775 #if 0
 776     /* XXX: check that enough room is available */
 777     push_size = 6 + (new_stack << 2) + (has_error_code << 1);
 778     if (env->eflags & VM_MASK)
 779         push_size += 8;
 780     push_size <<= shift;
 781 #endif
 782     if (shift == 1) {
 783         if (new_stack) {
 784             if (env->eflags & VM_MASK) {
 785                 PUSHL(ssp, esp, sp_mask, env->segs[R_GS].selector);
 786                 PUSHL(ssp, esp, sp_mask, env->segs[R_FS].selector);
 787                 PUSHL(ssp, esp, sp_mask, env->segs[R_DS].selector);
 788                 PUSHL(ssp, esp, sp_mask, env->segs[R_ES].selector);
 789             }
 790             PUSHL(ssp, esp, sp_mask, env->segs[R_SS].selector);
 791             PUSHL(ssp, esp, sp_mask, ESP);
 792         }
 793         PUSHL(ssp, esp, sp_mask, compute_eflags());
 794         PUSHL(ssp, esp, sp_mask, env->segs[R_CS].selector);
 795         PUSHL(ssp, esp, sp_mask, old_eip);
 796         if (has_error_code) {
 797             PUSHL(ssp, esp, sp_mask, error_code);
 798         }
 799     } else {
 800         if (new_stack) {
 801             if (env->eflags & VM_MASK) {
 802                 PUSHW(ssp, esp, sp_mask, env->segs[R_GS].selector);
 803                 PUSHW(ssp, esp, sp_mask, env->segs[R_FS].selector);
 804                 PUSHW(ssp, esp, sp_mask, env->segs[R_DS].selector);
 805                 PUSHW(ssp, esp, sp_mask, env->segs[R_ES].selector);
 806             }
 807             PUSHW(ssp, esp, sp_mask, env->segs[R_SS].selector);
 808             PUSHW(ssp, esp, sp_mask, ESP);
 809         }
 810         PUSHW(ssp, esp, sp_mask, compute_eflags());
 811         PUSHW(ssp, esp, sp_mask, env->segs[R_CS].selector);
 812         PUSHW(ssp, esp, sp_mask, old_eip);
 813         if (has_error_code) {
 814             PUSHW(ssp, esp, sp_mask, error_code);
 815         }
 816     }
 817
 818     if (new_stack) {
 819         if (env->eflags & VM_MASK) {
 820             cpu_x86_load_seg_cache(env, R_ES, 0, 0, 0, 0);
 821             cpu_x86_load_seg_cache(env, R_DS, 0, 0, 0, 0);
 822             cpu_x86_load_seg_cache(env, R_FS, 0, 0, 0, 0);
 823             cpu_x86_load_seg_cache(env, R_GS, 0, 0, 0, 0);
 824         }
 825         ss = (ss & ~3) | dpl;
 826         cpu_x86_load_seg_cache(env, R_SS, ss,
 827                                ssp, get_seg_limit(ss_e1, ss_e2), ss_e2);
 828     }
 829     SET_ESP(esp, sp_mask);
 830
 831     selector = (selector & ~3) | dpl;
 832     cpu_x86_load_seg_cache(env, R_CS, selector,
 833                    get_seg_base(e1, e2),
 834                    get_seg_limit(e1, e2),
 835                    e2);
 836     cpu_x86_set_cpl(env, dpl);
 837     env->eip = offset;
 838
 839     /* interrupt gate clear IF mask */
 840     if ((type & 1) == 0) {
 841         env->eflags &= ~IF_MASK;
 842     }
 843     env->eflags &= ~(TF_MASK | VM_MASK | RF_MASK | NT_MASK);
 844 }
 845
 846 #ifdef TARGET_X86_64
 847
 848 #define PUSHQ(sp, val)\
 849 {\
 850     sp -= 8;\
 851     stq_kernel(sp, (val));\
 852 }
 853
 854 #define POPQ(sp, val)\
 855 {\
 856     val = ldq_kernel(sp);\
 857     sp += 8;\
 858 }
 859
 860 static inline target_ulong get_rsp_from_tss(int level)
 861 {
 862     int index;
 863
 864 #if 0
 865     printf("TR: base=" TARGET_FMT_lx " limit=%x\n",
 866            env->tr.base, env->tr.limit);
 867 #endif
 868
 869     if (!(env->tr.flags & DESC_P_MASK))
 870         cpu_abort(env, "invalid tss");
 871     index = 8 * level + 4;
 872     if ((index + 7) > env->tr.limit)
 873         raise_exception_err(EXCP0A_TSS, env->tr.selector & 0xfffc);
 874     return ldq_kernel(env->tr.base + index);
 875 }
 876
 877 /* 64 bit interrupt */
 878 static void do_interrupt64(int intno, int is_int, int error_code,
 879                            target_ulong next_eip, int is_hw)
 880 {
 881     SegmentCache *dt;
 882     target_ulong ptr;
 883     int type, dpl, selector, cpl, ist;
 884     int has_error_code, new_stack;
 885     uint32_t e1, e2, e3, ss;
 886     target_ulong old_eip, esp, offset;
 887
 888     has_error_code = 0;
 889     if (!is_int && !is_hw) {
 890         switch(intno) {
 891         case 8:
 892         case 10:
 893         case 11:
 894         case 12:
 895         case 13:
 896         case 14:
 897         case 17:
 898             has_error_code = 1;
 899             break;
 900         }
 901     }
 902     if (is_int)
 903         old_eip = next_eip;
 904     else
 905         old_eip = env->eip;
 906
 907     dt = &env->idt;
 908     if (intno * 16 + 15 > dt->limit)
 909         raise_exception_err(EXCP0D_GPF, intno * 16 + 2);
 910     ptr = dt->base + intno * 16;
 911     e1 = ldl_kernel(ptr);
 912     e2 = ldl_kernel(ptr + 4);
 913     e3 = ldl_kernel(ptr + 8);
 914     /* check gate type */
 915     type = (e2 >> DESC_TYPE_SHIFT) & 0x1f;
 916     switch(type) {
 917     case 14: /* 386 interrupt gate */
 918     case 15: /* 386 trap gate */
 919         break;
 920     default:
 921         raise_exception_err(EXCP0D_GPF, intno * 16 + 2);
 922         break;
 923     }
 924     dpl = (e2 >> DESC_DPL_SHIFT) & 3;
 925     cpl = env->hflags & HF_CPL_MASK;
 926     /* check privilege if software int */
 927     if (is_int && dpl < cpl)
 928         raise_exception_err(EXCP0D_GPF, intno * 16 + 2);
 929     /* check valid bit */
 930     if (!(e2 & DESC_P_MASK))
 931         raise_exception_err(EXCP0B_NOSEG, intno * 16 + 2);
 932     selector = e1 >> 16;
 933     offset = ((target_ulong)e3 << 32) | (e2 & 0xffff0000) | (e1 & 0x0000ffff);
 934     ist = e2 & 7;
 935     if ((selector & 0xfffc) == 0)
 936         raise_exception_err(EXCP0D_GPF, 0);
 937
 938     if (load_segment(&e1, &e2, selector) != 0)
 939         raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
 940     if (!(e2 & DESC_S_MASK) || !(e2 & (DESC_CS_MASK)))
 941         raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
 942     dpl = (e2 >> DESC_DPL_SHIFT) & 3;
 943     if (dpl > cpl)
 944         raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
 945     if (!(e2 & DESC_P_MASK))
 946         raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
 947     if (!(e2 & DESC_L_MASK) || (e2 & DESC_B_MASK))
 948         raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
 949     if ((!(e2 & DESC_C_MASK) && dpl < cpl) || ist != 0) {
 950         /* to inner privilege */
 951         if (ist != 0)
 952             esp = get_rsp_from_tss(ist + 3);
 953         else
 954             esp = get_rsp_from_tss(dpl);
 955         esp &= ~0xfLL; /* align stack */
 956         ss = 0;
 957         new_stack = 1;
 958     } else if ((e2 & DESC_C_MASK) || dpl == cpl) {
 959         /* to same privilege */
 960         if (env->eflags & VM_MASK)
 961             raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
 962         new_stack = 0;
 963         if (ist != 0)
 964             esp = get_rsp_from_tss(ist + 3);
 965         else
 966             esp = ESP;
 967         esp &= ~0xfLL; /* align stack */
 968         dpl = cpl;
 969     } else {
 970         raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
 971         new_stack = 0; /* avoid warning */
 972         esp = 0; /* avoid warning */
 973     }
 974
 975     PUSHQ(esp, env->segs[R_SS].selector);
 976     PUSHQ(esp, ESP);
 977     PUSHQ(esp, compute_eflags());
 978     PUSHQ(esp, env->segs[R_CS].selector);
 979     PUSHQ(esp, old_eip);
 980     if (has_error_code) {
 981         PUSHQ(esp, error_code);
 982     }
 983
 984     if (new_stack) {
 985         ss = 0 | dpl;
 986         cpu_x86_load_seg_cache(env, R_SS, ss, 0, 0, 0);
 987     }
 988     ESP = esp;
 989
 990     selector = (selector & ~3) | dpl;
 991     cpu_x86_load_seg_cache(env, R_CS, selector,
 992                    get_seg_base(e1, e2),
 993                    get_seg_limit(e1, e2),
 994                    e2);
 995     cpu_x86_set_cpl(env, dpl);
 996     env->eip = offset;
 997
 998     /* interrupt gate clear IF mask */
 999     if ((type & 1) == 0) {
1000         env->eflags &= ~IF_MASK;
1001     }
1002     env->eflags &= ~(TF_MASK | VM_MASK | RF_MASK | NT_MASK);
1003 }
1004 #endif
1005
1006 #ifdef TARGET_X86_64
1007 #if defined(CONFIG_USER_ONLY)
1008 void helper_syscall(int next_eip_addend)
1009 {
1010     env->exception_index = EXCP_SYSCALL;
1011     env->exception_next_eip = env->eip + next_eip_addend;
1012     cpu_loop_exit();
1013 }
1014 #else
1015 void helper_syscall(int next_eip_addend)
1016 {
1017     int selector;
1018
1019     if (!(env->efer & MSR_EFER_SCE)) {
1020         raise_exception_err(EXCP06_ILLOP, 0);
1021     }
1022     selector = (env->star >> 32) & 0xffff;
1023     if (env->hflags & HF_LMA_MASK) {
1024         int code64;
1025
1026         ECX = env->eip + next_eip_addend;
1027         env->regs[11] = compute_eflags();
1028
1029         code64 = env->hflags & HF_CS64_MASK;
1030
1031         cpu_x86_set_cpl(env, 0);
1032         cpu_x86_load_seg_cache(env, R_CS, selector & 0xfffc,
1033                            0, 0xffffffff,
1034                                DESC_G_MASK | DESC_P_MASK |
1035                                DESC_S_MASK |
1036                                DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK | DESC_L_MASK);
1037         cpu_x86_load_seg_cache(env, R_SS, (selector + 8) & 0xfffc,
1038                                0, 0xffffffff,
1039                                DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
1040                                DESC_S_MASK |
1041                                DESC_W_MASK | DESC_A_MASK);
1042         env->eflags &= ~env->fmask;
1043         load_eflags(env->eflags, 0);
1044         if (code64)
1045             env->eip = env->lstar;
1046         else
1047             env->eip = env->cstar;
1048     } else {
1049         ECX = (uint32_t)(env->eip + next_eip_addend);
1050
1051         cpu_x86_set_cpl(env, 0);
1052         cpu_x86_load_seg_cache(env, R_CS, selector & 0xfffc,
1053                            0, 0xffffffff,
1054                                DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
1055                                DESC_S_MASK |
1056                                DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);
1057         cpu_x86_load_seg_cache(env, R_SS, (selector + 8) & 0xfffc,
1058                                0, 0xffffffff,
1059                                DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
1060                                DESC_S_MASK |
1061                                DESC_W_MASK | DESC_A_MASK);
1062         env->eflags &= ~(IF_MASK | RF_MASK | VM_MASK);
1063         env->eip = (uint32_t)env->star;
1064     }
1065 }
1066 #endif
1067 #endif
1068
1069 #ifdef TARGET_X86_64
1070 void helper_sysret(int dflag)
1071 {
1072     int cpl, selector;
1073
1074     if (!(env->efer & MSR_EFER_SCE)) {
1075         raise_exception_err(EXCP06_ILLOP, 0);
1076     }
1077     cpl = env->hflags & HF_CPL_MASK;
1078     if (!(env->cr[0] & CR0_PE_MASK) || cpl != 0) {
1079         raise_exception_err(EXCP0D_GPF, 0);
1080     }
1081     selector = (env->star >> 48) & 0xffff;
1082     if (env->hflags & HF_LMA_MASK) {
1083         if (dflag == 2) {
1084             cpu_x86_load_seg_cache(env, R_CS, (selector + 16) | 3,
1085                                    0, 0xffffffff,
1086                                    DESC_G_MASK | DESC_P_MASK |
1087                                    DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
1088                                    DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK |
1089                                    DESC_L_MASK);
1090             env->eip = ECX;
1091         } else {
1092             cpu_x86_load_seg_cache(env, R_CS, selector | 3,
1093                                    0, 0xffffffff,
1094                                    DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
1095                                    DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
1096                                    DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);
1097             env->eip = (uint32_t)ECX;
1098         }
1099         cpu_x86_load_seg_cache(env, R_SS, selector + 8,
1100                                0, 0xffffffff,
1101                                DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
1102                                DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
1103                                DESC_W_MASK | DESC_A_MASK);
1104         load_eflags((uint32_t)(env->regs[11]), TF_MASK | AC_MASK | ID_MASK |
1105                     IF_MASK | IOPL_MASK | VM_MASK | RF_MASK | NT_MASK);
1106         cpu_x86_set_cpl(env, 3);
1107     } else {
1108         cpu_x86_load_seg_cache(env, R_CS, selector | 3,
1109                                0, 0xffffffff,
1110                                DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
1111                                DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
1112                                DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);
1113         env->eip = (uint32_t)ECX;
1114         cpu_x86_load_seg_cache(env, R_SS, selector + 8,
1115                                0, 0xffffffff,
1116                                DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
1117                                DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
1118                                DESC_W_MASK | DESC_A_MASK);
1119         env->eflags |= IF_MASK;
1120         cpu_x86_set_cpl(env, 3);
1121     }
1122 #ifdef USE_KQEMU
1123     if (kqemu_is_ok(env)) {
1124         if (env->hflags & HF_LMA_MASK)
1125             CC_OP = CC_OP_EFLAGS;
1126         env->exception_index = -1;
1127         cpu_loop_exit();
1128     }
1129 #endif
1130 }
1131 #endif
1132
1133 /* real mode interrupt */
1134 static void do_interrupt_real(int intno, int is_int, int error_code,
1135                               unsigned int next_eip)
1136 {
1137     SegmentCache *dt;
1138     target_ulong ptr, ssp;
1139     int selector;
1140     uint32_t offset, esp;
1141     uint32_t old_cs, old_eip;
1142
1143     /* real mode (simpler !) */
1144     dt = &env->idt;
1145     if (intno * 4 + 3 > dt->limit)
1146         raise_exception_err(EXCP0D_GPF, intno * 8 + 2);
1147     ptr = dt->base + intno * 4;
1148     offset = lduw_kernel(ptr);
1149     selector = lduw_kernel(ptr + 2);
1150     esp = ESP;
1151     ssp = env->segs[R_SS].base;
1152     if (is_int)
1153         old_eip = next_eip;
1154     else
1155         old_eip = env->eip;
1156     old_cs = env->segs[R_CS].selector;
1157     /* XXX: use SS segment size ? */
1158     PUSHW(ssp, esp, 0xffff, compute_eflags());
1159     PUSHW(ssp, esp, 0xffff, old_cs);
1160     PUSHW(ssp, esp, 0xffff, old_eip);
1161
1162     /* update processor state */
1163     ESP = (ESP & ~0xffff) | (esp & 0xffff);
1164     env->eip = offset;
1165     env->segs[R_CS].selector = selector;
1166     env->segs[R_CS].base = (selector << 4);
1167     env->eflags &= ~(IF_MASK | TF_MASK | AC_MASK | RF_MASK);
1168 }
1169
1170 /* fake user mode interrupt */
1171 void do_interrupt_user(int intno, int is_int, int error_code,
1172                        target_ulong next_eip)
1173 {
1174     SegmentCache *dt;
1175     target_ulong ptr;
1176     int dpl, cpl, shift;
1177     uint32_t e2;
1178
1179     dt = &env->idt;
1180     if (env->hflags & HF_LMA_MASK) {
1181         shift = 4;
1182     } else {
1183         shift = 3;
1184     }
1185     ptr = dt->base + (intno << shift);
1186     e2 = ldl_kernel(ptr + 4);
1187
1188     dpl = (e2 >> DESC_DPL_SHIFT) & 3;
1189     cpl = env->hflags & HF_CPL_MASK;
1190     /* check privilege if software int */
1191     if (is_int && dpl < cpl)
1192         raise_exception_err(EXCP0D_GPF, (intno << shift) + 2);
1193
1194     /* Since we emulate only user space, we cannot do more than
1195        exiting the emulation with the suitable exception and error
1196        code */
1197     if (is_int)
1198         EIP = next_eip;
1199 }
1200
1201 /*
1202  * Begin execution of an interruption. is_int is TRUE if coming from
1203  * the int instruction. next_eip is the EIP value AFTER the interrupt
1204  * instruction. It is only relevant if is_int is TRUE.
1205  */
1206 void do_interrupt(int intno, int is_int, int error_code,
1207                   target_ulong next_eip, int is_hw)
1208 {
1209     if (qemu_loglevel_mask(CPU_LOG_INT)) {
1210         if ((env->cr[0] & CR0_PE_MASK)) {
1211             static int count;
1212             qemu_log("%6d: v=%02x e=%04x i=%d cpl=%d IP=%04x:" TARGET_FMT_lx " pc=" TARGET_FMT_lx " SP=%04x:" TARGET_FMT_lx,
1213                     count, intno, error_code, is_int,
1214                     env->hflags & HF_CPL_MASK,
1215                     env->segs[R_CS].selector, EIP,
1216                     (int)env->segs[R_CS].base + EIP,
1217                     env->segs[R_SS].selector, ESP);
1218             if (intno == 0x0e) {
1219                 qemu_log(" CR2=" TARGET_FMT_lx, env->cr[2]);
1220             } else {
1221                 qemu_log(" EAX=" TARGET_FMT_lx, EAX);
1222             }
1223             qemu_log("\n");
1224             log_cpu_state(env, X86_DUMP_CCOP);
1225 #if 0
1226             {
1227                 int i;
1228                 uint8_t *ptr;
1229                 qemu_log("       code=");
1230                 ptr = env->segs[R_CS].base + env->eip;
1231                 for(i = 0; i < 16; i++) {
1232                     qemu_log(" %02x", ldub(ptr + i));
1233                 }
1234                 qemu_log("\n");
1235             }
1236 #endif
1237             count++;
1238         }
1239     }
1240     if (env->cr[0] & CR0_PE_MASK) {
1241 #ifdef TARGET_X86_64
1242         if (env->hflags & HF_LMA_MASK) {
1243             do_interrupt64(intno, is_int, error_code, next_eip, is_hw);
1244         } else
1245 #endif
1246         {
1247             do_interrupt_protected(intno, is_int, error_code, next_eip, is_hw);
1248         }
1249     } else {
1250         do_interrupt_real(intno, is_int, error_code, next_eip);
1251     }
1252 }
1253
1254 /* This should come from sysemu.h - if we could include it here... */
1255 void qemu_system_reset_request(void);
1256
1257 /*
1258  * Check nested exceptions and change to double or triple fault if
1259  * needed. It should only be called, if this is not an interrupt.
1260  * Returns the new exception number.
1261  */
1262 static int check_exception(int intno, int *error_code)
1263 {
1264     int first_contributory = env->old_exception == 0 ||
1265                               (env->old_exception >= 10 &&
1266                                env->old_exception <= 13);
1267     int second_contributory = intno == 0 ||
1268                                (intno >= 10 && intno <= 13);
1269
1270     qemu_log_mask(CPU_LOG_INT, "check_exception old: 0x%x new 0x%x\n",
1271                 env->old_exception, intno);
1272
1273 #if !defined(CONFIG_USER_ONLY)
1274     if (env->old_exception == EXCP08_DBLE) {
1275         if (env->hflags & HF_SVMI_MASK)
1276             helper_vmexit(SVM_EXIT_SHUTDOWN, 0); /* does not return */
1277
1278         qemu_log_mask(CPU_LOG_RESET, "Triple fault\n");
1279
1280         qemu_system_reset_request();
1281         return EXCP_HLT;
1282     }
1283 #endif
1284
1285     if ((first_contributory && second_contributory)
1286         || (env->old_exception == EXCP0E_PAGE &&
1287             (second_contributory || (intno == EXCP0E_PAGE)))) {
1288         intno = EXCP08_DBLE;
1289         *error_code = 0;
1290     }
1291
1292     if (second_contributory || (intno == EXCP0E_PAGE) ||
1293         (intno == EXCP08_DBLE))
1294         env->old_exception = intno;
1295
1296     return intno;
1297 }
1298
1299 /*
1300  * Signal an interruption. It is executed in the main CPU loop.
1301  * is_int is TRUE if coming from the int instruction. next_eip is the
1302  * EIP value AFTER the interrupt instruction. It is only relevant if
1303  * is_int is TRUE.
1304  */
1305 static void QEMU_NORETURN raise_interrupt(int intno, int is_int, int error_code,
1306                                           int next_eip_addend)
1307 {
1308     if (!is_int) {
1309         helper_svm_check_intercept_param(SVM_EXIT_EXCP_BASE + intno, error_code);
1310         intno = check_exception(intno, &error_code);
1311     } else {
1312         helper_svm_check_intercept_param(SVM_EXIT_SWINT, 0);
1313     }
1314
1315     env->exception_index = intno;
1316     env->error_code = error_code;
1317     env->exception_is_int = is_int;
1318     env->exception_next_eip = env->eip + next_eip_addend;
1319     cpu_loop_exit();
1320 }
1321
1322 /* shortcuts to generate exceptions */
1323
1324 void raise_exception_err(int exception_index, int error_code)
1325 {
1326     raise_interrupt(exception_index, 0, error_code, 0);
1327 }
1328
1329 void raise_exception(int exception_index)
1330 {
1331     raise_interrupt(exception_index, 0, 0, 0);
1332 }
1333
1334 /* SMM support */
1335
1336 #if defined(CONFIG_USER_ONLY)
1337
1338 void do_smm_enter(void)
1339 {
1340 }
1341
1342 void helper_rsm(void)
1343 {
1344 }
1345
1346 #else
1347
1348 #ifdef TARGET_X86_64
1349 #define SMM_REVISION_ID 0x00020064
1350 #else
1351 #define SMM_REVISION_ID 0x00020000
1352 #endif
1353
1354 void do_smm_enter(void)
1355 {
1356     target_ulong sm_state;
1357     SegmentCache *dt;
1358     int i, offset;
1359
1360     qemu_log_mask(CPU_LOG_INT, "SMM: enter\n");
1361     log_cpu_state_mask(CPU_LOG_INT, env, X86_DUMP_CCOP);
1362
1363     env->hflags |= HF_SMM_MASK;
1364     cpu_smm_update(env);
1365
1366     sm_state = env->smbase + 0x8000;
1367
1368 #ifdef TARGET_X86_64
1369     for(i = 0; i < 6; i++) {
1370         dt = &env->segs[i];
1371         offset = 0x7e00 + i * 16;
1372         stw_phys(sm_state + offset, dt->selector);
1373         stw_phys(sm_state + offset + 2, (dt->flags >> 8) & 0xf0ff);
1374         stl_phys(sm_state + offset + 4, dt->limit);
1375         stq_phys(sm_state + offset + 8, dt->base);
1376     }
1377
1378     stq_phys(sm_state + 0x7e68, env->gdt.base);
1379     stl_phys(sm_state + 0x7e64, env->gdt.limit);
1380
1381     stw_phys(sm_state + 0x7e70, env->ldt.selector);
1382     stq_phys(sm_state + 0x7e78, env->ldt.base);
1383     stl_phys(sm_state + 0x7e74, env->ldt.limit);
1384     stw_phys(sm_state + 0x7e72, (env->ldt.flags >> 8) & 0xf0ff);
1385
1386     stq_phys(sm_state + 0x7e88, env->idt.base);
1387     stl_phys(sm_state + 0x7e84, env->idt.limit);
1388
1389     stw_phys(sm_state + 0x7e90, env->tr.selector);
1390     stq_phys(sm_state + 0x7e98, env->tr.base);
1391     stl_phys(sm_state + 0x7e94, env->tr.limit);
1392     stw_phys(sm_state + 0x7e92, (env->tr.flags >> 8) & 0xf0ff);
1393
1394     stq_phys(sm_state + 0x7ed0, env->efer);
1395
1396     stq_phys(sm_state + 0x7ff8, EAX);
1397     stq_phys(sm_state + 0x7ff0, ECX);
1398     stq_phys(sm_state + 0x7fe8, EDX);
1399     stq_phys(sm_state + 0x7fe0, EBX);
1400     stq_phys(sm_state + 0x7fd8, ESP);
1401     stq_phys(sm_state + 0x7fd0, EBP);
1402     stq_phys(sm_state + 0x7fc8, ESI);
1403     stq_phys(sm_state + 0x7fc0, EDI);
1404     for(i = 8; i < 16; i++)
1405         stq_phys(sm_state + 0x7ff8 - i * 8, env->regs[i]);
1406     stq_phys(sm_state + 0x7f78, env->eip);
1407     stl_phys(sm_state + 0x7f70, compute_eflags());
1408     stl_phys(sm_state + 0x7f68, env->dr[6]);
1409     stl_phys(sm_state + 0x7f60, env->dr[7]);
1410
1411     stl_phys(sm_state + 0x7f48, env->cr[4]);
1412     stl_phys(sm_state + 0x7f50, env->cr[3]);
1413     stl_phys(sm_state + 0x7f58, env->cr[0]);
1414
1415     stl_phys(sm_state + 0x7efc, SMM_REVISION_ID);
1416     stl_phys(sm_state + 0x7f00, env->smbase);
1417 #else
1418     stl_phys(sm_state + 0x7ffc, env->cr[0]);
1419     stl_phys(sm_state + 0x7ff8, env->cr[3]);
1420     stl_phys(sm_state + 0x7ff4, compute_eflags());
1421     stl_phys(sm_state + 0x7ff0, env->eip);
1422     stl_phys(sm_state + 0x7fec, EDI);
1423     stl_phys(sm_state + 0x7fe8, ESI);
1424     stl_phys(sm_state + 0x7fe4, EBP);
1425     stl_phys(sm_state + 0x7fe0, ESP);
1426     stl_phys(sm_state + 0x7fdc, EBX);
1427     stl_phys(sm_state + 0x7fd8, EDX);
1428     stl_phys(sm_state + 0x7fd4, ECX);
1429     stl_phys(sm_state + 0x7fd0, EAX);
1430     stl_phys(sm_state + 0x7fcc, env->dr[6]);
1431     stl_phys(sm_state + 0x7fc8, env->dr[7]);
1432
1433     stl_phys(sm_state + 0x7fc4, env->tr.selector);
1434     stl_phys(sm_state + 0x7f64, env->tr.base);
1435     stl_phys(sm_state + 0x7f60, env->tr.limit);
1436     stl_phys(sm_state + 0x7f5c, (env->tr.flags >> 8) & 0xf0ff);
1437
1438     stl_phys(sm_state + 0x7fc0, env->ldt.selector);
1439     stl_phys(sm_state + 0x7f80, env->ldt.base);
1440     stl_phys(sm_state + 0x7f7c, env->ldt.limit);
1441     stl_phys(sm_state + 0x7f78, (env->ldt.flags >> 8) & 0xf0ff);
1442
1443     stl_phys(sm_state + 0x7f74, env->gdt.base);
1444     stl_phys(sm_state + 0x7f70, env->gdt.limit);
1445
1446     stl_phys(sm_state + 0x7f58, env->idt.base);
1447     stl_phys(sm_state + 0x7f54, env->idt.limit);
1448
1449     for(i = 0; i < 6; i++) {
1450         dt = &env->segs[i];
1451         if (i < 3)
1452             offset = 0x7f84 + i * 12;
1453         else
1454             offset = 0x7f2c + (i - 3) * 12;
1455         stl_phys(sm_state + 0x7fa8 + i * 4, dt->selector);
1456         stl_phys(sm_state + offset + 8, dt->base);
1457         stl_phys(sm_state + offset + 4, dt->limit);
1458         stl_phys(sm_state + offset, (dt->flags >> 8) & 0xf0ff);
1459     }
1460     stl_phys(sm_state + 0x7f14, env->cr[4]);
1461
1462     stl_phys(sm_state + 0x7efc, SMM_REVISION_ID);
1463     stl_phys(sm_state + 0x7ef8, env->smbase);
1464 #endif
1465     /* init SMM cpu state */
1466
1467 #ifdef TARGET_X86_64
1468     cpu_load_efer(env, 0);
1469 #endif
1470     load_eflags(0, ~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
1471     env->eip = 0x00008000;
1472     cpu_x86_load_seg_cache(env, R_CS, (env->smbase >> 4) & 0xffff, env->smbase,
1473                            0xffffffff, 0);
1474     cpu_x86_load_seg_cache(env, R_DS, 0, 0, 0xffffffff, 0);
1475     cpu_x86_load_seg_cache(env, R_ES, 0, 0, 0xffffffff, 0);
1476     cpu_x86_load_seg_cache(env, R_SS, 0, 0, 0xffffffff, 0);
1477     cpu_x86_load_seg_cache(env, R_FS, 0, 0, 0xffffffff, 0);
1478     cpu_x86_load_seg_cache(env, R_GS, 0, 0, 0xffffffff, 0);
1479
1480     cpu_x86_update_cr0(env,
1481                        env->cr[0] & ~(CR0_PE_MASK | CR0_EM_MASK | CR0_TS_MASK | CR0_PG_MASK));
1482     cpu_x86_update_cr4(env, 0);
1483     env->dr[7] = 0x00000400;
1484     CC_OP = CC_OP_EFLAGS;
1485 }
1486
1487 void helper_rsm(void)
1488 {
1489     target_ulong sm_state;
1490     int i, offset;
1491     uint32_t val;
1492
1493     sm_state = env->smbase + 0x8000;
1494 #ifdef TARGET_X86_64
1495     cpu_load_efer(env, ldq_phys(sm_state + 0x7ed0));
1496
1497     for(i = 0; i < 6; i++) {
1498         offset = 0x7e00 + i * 16;
1499         cpu_x86_load_seg_cache(env, i,
1500                                lduw_phys(sm_state + offset),
1501                                ldq_phys(sm_state + offset + 8),
1502                                ldl_phys(sm_state + offset + 4),
1503                                (lduw_phys(sm_state + offset + 2) & 0xf0ff) << 8);
1504     }
1505
1506     env->gdt.base = ldq_phys(sm_state + 0x7e68);
1507     env->gdt.limit = ldl_phys(sm_state + 0x7e64);
1508
1509     env->ldt.selector = lduw_phys(sm_state + 0x7e70);
1510     env->ldt.base = ldq_phys(sm_state + 0x7e78);
1511     env->ldt.limit = ldl_phys(sm_state + 0x7e74);
1512     env->ldt.flags = (lduw_phys(sm_state + 0x7e72) & 0xf0ff) << 8;
1513
1514     env->idt.base = ldq_phys(sm_state + 0x7e88);
1515     env->idt.limit = ldl_phys(sm_state + 0x7e84);
1516
1517     env->tr.selector = lduw_phys(sm_state + 0x7e90);
1518     env->tr.base = ldq_phys(sm_state + 0x7e98);
1519     env->tr.limit = ldl_phys(sm_state + 0x7e94);
1520     env->tr.flags = (lduw_phys(sm_state + 0x7e92) & 0xf0ff) << 8;
1521
1522     EAX = ldq_phys(sm_state + 0x7ff8);
1523     ECX = ldq_phys(sm_state + 0x7ff0);
1524     EDX = ldq_phys(sm_state + 0x7fe8);
1525     EBX = ldq_phys(sm_state + 0x7fe0);
1526     ESP = ldq_phys(sm_state + 0x7fd8);
1527     EBP = ldq_phys(sm_state + 0x7fd0);
1528     ESI = ldq_phys(sm_state + 0x7fc8);
1529     EDI = ldq_phys(sm_state + 0x7fc0);
1530     for(i = 8; i < 16; i++)
1531         env->regs[i] = ldq_phys(sm_state + 0x7ff8 - i * 8);
1532     env->eip = ldq_phys(sm_state + 0x7f78);
1533     load_eflags(ldl_phys(sm_state + 0x7f70),
1534                 ~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
1535     env->dr[6] = ldl_phys(sm_state + 0x7f68);
1536     env->dr[7] = ldl_phys(sm_state + 0x7f60);
1537
1538     cpu_x86_update_cr4(env, ldl_phys(sm_state + 0x7f48));
1539     cpu_x86_update_cr3(env, ldl_phys(sm_state + 0x7f50));
1540     cpu_x86_update_cr0(env, ldl_phys(sm_state + 0x7f58));
1541
1542     val = ldl_phys(sm_state + 0x7efc); /* revision ID */
1543     if (val & 0x20000) {
1544         env->smbase = ldl_phys(sm_state + 0x7f00) & ~0x7fff;
1545     }
1546 #else
1547     cpu_x86_update_cr0(env, ldl_phys(sm_state + 0x7ffc));
1548     cpu_x86_update_cr3(env, ldl_phys(sm_state + 0x7ff8));
1549     load_eflags(ldl_phys(sm_state + 0x7ff4),
1550                 ~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
1551     env->eip = ldl_phys(sm_state + 0x7ff0);
1552     EDI = ldl_phys(sm_state + 0x7fec);
1553     ESI = ldl_phys(sm_state + 0x7fe8);
1554     EBP = ldl_phys(sm_state + 0x7fe4);
1555     ESP = ldl_phys(sm_state + 0x7fe0);
1556     EBX = ldl_phys(sm_state + 0x7fdc);
1557     EDX = ldl_phys(sm_state + 0x7fd8);
1558     ECX = ldl_phys(sm_state + 0x7fd4);
1559     EAX = ldl_phys(sm_state + 0x7fd0);
1560     env->dr[6] = ldl_phys(sm_state + 0x7fcc);
1561     env->dr[7] = ldl_phys(sm_state + 0x7fc8);
1562
1563     env->tr.selector = ldl_phys(sm_state + 0x7fc4) & 0xffff;
1564     env->tr.base = ldl_phys(sm_state + 0x7f64);
1565     env->tr.limit = ldl_phys(sm_state + 0x7f60);
1566     env->tr.flags = (ldl_phys(sm_state + 0x7f5c) & 0xf0ff) << 8;
1567
1568     env->ldt.selector = ldl_phys(sm_state + 0x7fc0) & 0xffff;
1569     env->ldt.base = ldl_phys(sm_state + 0x7f80);
1570     env->ldt.limit = ldl_phys(sm_state + 0x7f7c);
1571     env->ldt.flags = (ldl_phys(sm_state + 0x7f78) & 0xf0ff) << 8;
1572
1573     env->gdt.base = ldl_phys(sm_state + 0x7f74);
1574     env->gdt.limit = ldl_phys(sm_state + 0x7f70);
1575
1576     env->idt.base = ldl_phys(sm_state + 0x7f58);
1577     env->idt.limit = ldl_phys(sm_state + 0x7f54);
1578
1579     for(i = 0; i < 6; i++) {
1580         if (i < 3)
1581             offset = 0x7f84 + i * 12;
1582         else
1583             offset = 0x7f2c + (i - 3) * 12;
1584         cpu_x86_load_seg_cache(env, i,
1585                                ldl_phys(sm_state + 0x7fa8 + i * 4) & 0xffff,
1586                                ldl_phys(sm_state + offset + 8),
1587                                ldl_phys(sm_state + offset + 4),
1588                                (ldl_phys(sm_state + offset) & 0xf0ff) << 8);
1589     }
1590     cpu_x86_update_cr4(env, ldl_phys(sm_state + 0x7f14));
1591
1592     val = ldl_phys(sm_state + 0x7efc); /* revision ID */
1593     if (val & 0x20000) {
1594         env->smbase = ldl_phys(sm_state + 0x7ef8) & ~0x7fff;
1595     }
1596 #endif
1597     CC_OP = CC_OP_EFLAGS;
1598     env->hflags &= ~HF_SMM_MASK;
1599     cpu_smm_update(env);
1600
1601     qemu_log_mask(CPU_LOG_INT, "SMM: after RSM\n");
1602     log_cpu_state_mask(CPU_LOG_INT, env, X86_DUMP_CCOP);
1603 }
1604
1605 #endif /* !CONFIG_USER_ONLY */
1606
1607
1608 /* division, flags are undefined */
1609
1610 void helper_divb_AL(target_ulong t0)
1611 {
1612     unsigned int num, den, q, r;
1613
1614     num = (EAX & 0xffff);
1615     den = (t0 & 0xff);
1616     if (den == 0) {
1617         raise_exception(EXCP00_DIVZ);
1618     }
1619     q = (num / den);
1620     if (q > 0xff)
1621         raise_exception(EXCP00_DIVZ);
1622     q &= 0xff;
1623     r = (num % den) & 0xff;
1624     EAX = (EAX & ~0xffff) | (r << 8) | q;
1625 }
1626
1627 void helper_idivb_AL(target_ulong t0)
1628 {
1629     int num, den, q, r;
1630
1631     num = (int16_t)EAX;
1632     den = (int8_t)t0;
1633     if (den == 0) {
1634         raise_exception(EXCP00_DIVZ);
1635     }
1636     q = (num / den);
1637     if (q != (int8_t)q)
1638         raise_exception(EXCP00_DIVZ);
1639     q &= 0xff;
1640     r = (num % den) & 0xff;
1641     EAX = (EAX & ~0xffff) | (r << 8) | q;
1642 }
1643
1644 void helper_divw_AX(target_ulong t0)
1645 {
1646     unsigned int num, den, q, r;
1647
1648     num = (EAX & 0xffff) | ((EDX & 0xffff) << 16);
1649     den = (t0 & 0xffff);
1650     if (den == 0) {
1651         raise_exception(EXCP00_DIVZ);
1652     }
1653     q = (num / den);
1654     if (q > 0xffff)
1655         raise_exception(EXCP00_DIVZ);
1656     q &= 0xffff;
1657     r = (num % den) & 0xffff;
1658     EAX = (EAX & ~0xffff) | q;
1659     EDX = (EDX & ~0xffff) | r;
1660 }
1661
1662 void helper_idivw_AX(target_ulong t0)
1663 {
1664     int num, den, q, r;
1665
1666     num = (EAX & 0xffff) | ((EDX & 0xffff) << 16);
1667     den = (int16_t)t0;
1668     if (den == 0) {
1669         raise_exception(EXCP00_DIVZ);
1670     }
1671     q = (num / den);
1672     if (q != (int16_t)q)
1673         raise_exception(EXCP00_DIVZ);
1674     q &= 0xffff;
1675     r = (num % den) & 0xffff;
1676     EAX = (EAX & ~0xffff) | q;
1677     EDX = (EDX & ~0xffff) | r;
1678 }
1679
1680 void helper_divl_EAX(target_ulong t0)
1681 {
1682     unsigned int den, r;
1683     uint64_t num, q;
1684
1685     num = ((uint32_t)EAX) | ((uint64_t)((uint32_t)EDX) << 32);
1686     den = t0;
1687     if (den == 0) {
1688         raise_exception(EXCP00_DIVZ);
1689     }
1690     q = (num / den);
1691     r = (num % den);
1692     if (q > 0xffffffff)
1693         raise_exception(EXCP00_DIVZ);
1694     EAX = (uint32_t)q;
1695     EDX = (uint32_t)r;
1696 }
1697
1698 void helper_idivl_EAX(target_ulong t0)
1699 {
1700     int den, r;
1701     int64_t num, q;
1702
1703     num = ((uint32_t)EAX) | ((uint64_t)((uint32_t)EDX) << 32);
1704     den = t0;
1705     if (den == 0) {
1706         raise_exception(EXCP00_DIVZ);
1707     }
1708     q = (num / den);
1709     r = (num % den);
1710     if (q != (int32_t)q)
1711         raise_exception(EXCP00_DIVZ);
1712     EAX = (uint32_t)q;
1713     EDX = (uint32_t)r;
1714 }
1715
1716 /* bcd */
1717
1718 /* XXX: exception */
1719 void helper_aam(int base)
1720 {
1721     int al, ah;
1722     al = EAX & 0xff;
1723     ah = al / base;
1724     al = al % base;
1725     EAX = (EAX & ~0xffff) | al | (ah << 8);
1726     CC_DST = al;
1727 }
1728
1729 void helper_aad(int base)
1730 {
1731     int al, ah;
1732     al = EAX & 0xff;
1733     ah = (EAX >> 8) & 0xff;
1734     al = ((ah * base) + al) & 0xff;
1735     EAX = (EAX & ~0xffff) | al;
1736     CC_DST = al;
1737 }
1738
1739 void helper_aaa(void)
1740 {
1741     int icarry;
1742     int al, ah, af;
1743     int eflags;
1744
1745     eflags = helper_cc_compute_all(CC_OP);
1746     af = eflags & CC_A;
1747     al = EAX & 0xff;
1748     ah = (EAX >> 8) & 0xff;
1749
1750     icarry = (al > 0xf9);
1751     if (((al & 0x0f) > 9 ) || af) {
1752         al = (al + 6) & 0x0f;
1753         ah = (ah + 1 + icarry) & 0xff;
1754         eflags |= CC_C | CC_A;
1755     } else {
1756         eflags &= ~(CC_C | CC_A);
1757         al &= 0x0f;
1758     }
1759     EAX = (EAX & ~0xffff) | al | (ah << 8);
1760     CC_SRC = eflags;
1761 }
1762
1763 void helper_aas(void)
1764 {
1765     int icarry;
1766     int al, ah, af;
1767     int eflags;
1768
1769     eflags = helper_cc_compute_all(CC_OP);
1770     af = eflags & CC_A;
1771     al = EAX & 0xff;
1772     ah = (EAX >> 8) & 0xff;
1773
1774     icarry = (al < 6);
1775     if (((al & 0x0f) > 9 ) || af) {
1776         al = (al - 6) & 0x0f;
1777         ah = (ah - 1 - icarry) & 0xff;
1778         eflags |= CC_C | CC_A;
1779     } else {
1780         eflags &= ~(CC_C | CC_A);
1781         al &= 0x0f;
1782     }
1783     EAX = (EAX & ~0xffff) | al | (ah << 8);
1784     CC_SRC = eflags;
1785 }
1786
1787 void helper_daa(void)
1788 {
1789     int al, af, cf;
1790     int eflags;
1791
1792     eflags = helper_cc_compute_all(CC_OP);
1793     cf = eflags & CC_C;
1794     af = eflags & CC_A;
1795     al = EAX & 0xff;
1796
1797     eflags = 0;
1798     if (((al & 0x0f) > 9 ) || af) {
1799         al = (al + 6) & 0xff;
1800         eflags |= CC_A;
1801     }
1802     if ((al > 0x9f) || cf) {
1803         al = (al + 0x60) & 0xff;
1804         eflags |= CC_C;
1805     }
1806     EAX = (EAX & ~0xff) | al;
1807     /* well, speed is not an issue here, so we compute the flags by hand */
1808     eflags |= (al == 0) << 6; /* zf */
1809     eflags |= parity_table[al]; /* pf */
1810     eflags |= (al & 0x80); /* sf */
1811     CC_SRC = eflags;
1812 }
1813
1814 void helper_das(void)
1815 {
1816     int al, al1, af, cf;
1817     int eflags;
1818
1819     eflags = helper_cc_compute_all(CC_OP);
1820     cf = eflags & CC_C;
1821     af = eflags & CC_A;
1822     al = EAX & 0xff;
1823
1824     eflags = 0;
1825     al1 = al;
1826     if (((al & 0x0f) > 9 ) || af) {
1827         eflags |= CC_A;
1828         if (al < 6 || cf)
1829             eflags |= CC_C;
1830         al = (al - 6) & 0xff;
1831     }
1832     if ((al1 > 0x99) || cf) {
1833         al = (al - 0x60) & 0xff;
1834         eflags |= CC_C;
1835     }
1836     EAX = (EAX & ~0xff) | al;
1837     /* well, speed is not an issue here, so we compute the flags by hand */
1838     eflags |= (al == 0) << 6; /* zf */
1839     eflags |= parity_table[al]; /* pf */
1840     eflags |= (al & 0x80); /* sf */
1841     CC_SRC = eflags;
1842 }
1843
1844 void helper_into(int next_eip_addend)
1845 {
1846     int eflags;
1847     eflags = helper_cc_compute_all(CC_OP);
1848     if (eflags & CC_O) {
1849         raise_interrupt(EXCP04_INTO, 1, 0, next_eip_addend);
1850     }
1851 }
1852
1853 void helper_cmpxchg8b(target_ulong a0)
1854 {
1855     uint64_t d;
1856     int eflags;
1857
1858     eflags = helper_cc_compute_all(CC_OP);
1859     d = ldq(a0);
1860     if (d == (((uint64_t)EDX << 32) | (uint32_t)EAX)) {
1861         stq(a0, ((uint64_t)ECX << 32) | (uint32_t)EBX);
1862         eflags |= CC_Z;
1863     } else {
1864         /* always do the store */
1865         stq(a0, d);
1866         EDX = (uint32_t)(d >> 32);
1867         EAX = (uint32_t)d;
1868         eflags &= ~CC_Z;
1869     }
1870     CC_SRC = eflags;
1871 }
1872
1873 #ifdef TARGET_X86_64
1874 void helper_cmpxchg16b(target_ulong a0)
1875 {
1876     uint64_t d0, d1;
1877     int eflags;
1878
1879     if ((a0 & 0xf) != 0)
1880         raise_exception(EXCP0D_GPF);
1881     eflags = helper_cc_compute_all(CC_OP);
1882     d0 = ldq(a0);
1883     d1 = ldq(a0 + 8);
1884     if (d0 == EAX && d1 == EDX) {
1885         stq(a0, EBX);
1886         stq(a0 + 8, ECX);
1887         eflags |= CC_Z;
1888     } else {
1889         /* always do the store */
1890         stq(a0, d0);
1891         stq(a0 + 8, d1);
1892         EDX = d1;
1893         EAX = d0;
1894         eflags &= ~CC_Z;
1895     }
1896     CC_SRC = eflags;
1897 }
1898 #endif
1899
1900 void helper_single_step(void)
1901 {
1902 #ifndef CONFIG_USER_ONLY
1903     check_hw_breakpoints(env, 1);
1904     env->dr[6] |= DR6_BS;
1905 #endif
1906     raise_exception(EXCP01_DB);
1907 }
1908
1909 void helper_cpuid(void)
1910 {
1911     uint32_t eax, ebx, ecx, edx;
1912
1913     helper_svm_check_intercept_param(SVM_EXIT_CPUID, 0);
1914
1915     cpu_x86_cpuid(env, (uint32_t)EAX, (uint32_t)ECX, &eax, &ebx, &ecx, &edx);
1916     EAX = eax;
1917     EBX = ebx;
1918     ECX = ecx;
1919     EDX = edx;
1920 }
1921
1922 void helper_enter_level(int level, int data32, target_ulong t1)
1923 {
1924     target_ulong ssp;
1925     uint32_t esp_mask, esp, ebp;
1926
1927     esp_mask = get_sp_mask(env->segs[R_SS].flags);
1928     ssp = env->segs[R_SS].base;
1929     ebp = EBP;
1930     esp = ESP;
1931     if (data32) {
1932         /* 32 bit */
1933         esp -= 4;
1934         while (--level) {
1935             esp -= 4;
1936             ebp -= 4;
1937             stl(ssp + (esp & esp_mask), ldl(ssp + (ebp & esp_mask)));
1938         }
1939         esp -= 4;
1940         stl(ssp + (esp & esp_mask), t1);
1941     } else {
1942         /* 16 bit */
1943         esp -= 2;
1944         while (--level) {
1945             esp -= 2;
1946             ebp -= 2;
1947             stw(ssp + (esp & esp_mask), lduw(ssp + (ebp & esp_mask)));
1948         }
1949         esp -= 2;
1950         stw(ssp + (esp & esp_mask), t1);
1951     }
1952 }
1953
1954 #ifdef TARGET_X86_64
1955 void helper_enter64_level(int level, int data64, target_ulong t1)
1956 {
1957     target_ulong esp, ebp;
1958     ebp = EBP;
1959     esp = ESP;
1960
1961     if (data64) {
1962         /* 64 bit */
1963         esp -= 8;
1964         while (--level) {
1965             esp -= 8;
1966             ebp -= 8;
1967             stq(esp, ldq(ebp));
1968         }
1969         esp -= 8;
1970         stq(esp, t1);
1971     } else {
1972         /* 16 bit */
1973         esp -= 2;
1974         while (--level) {
1975             esp -= 2;
1976             ebp -= 2;
1977             stw(esp, lduw(ebp));
1978         }
1979         esp -= 2;
1980         stw(esp, t1);
1981     }
1982 }
1983 #endif
1984
1985 void helper_lldt(int selector)
1986 {
1987     SegmentCache *dt;
1988     uint32_t e1, e2;
1989     int index, entry_limit;
1990     target_ulong ptr;
1991
1992     selector &= 0xffff;
1993     if ((selector & 0xfffc) == 0) {
1994         /* XXX: NULL selector case: invalid LDT */
1995         env->ldt.base = 0;
1996         env->ldt.limit = 0;
1997     } else {
1998         if (selector & 0x4)
1999             raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2000         dt = &env->gdt;
2001         index = selector & ~7;
2002 #ifdef TARGET_X86_64
2003         if (env->hflags & HF_LMA_MASK)
2004             entry_limit = 15;
2005         else
2006 #endif
2007             entry_limit = 7;
2008         if ((index + entry_limit) > dt->limit)
2009             raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2010         ptr = dt->base + index;
2011         e1 = ldl_kernel(ptr);
2012         e2 = ldl_kernel(ptr + 4);
2013         if ((e2 & DESC_S_MASK) || ((e2 >> DESC_TYPE_SHIFT) & 0xf) != 2)
2014             raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2015         if (!(e2 & DESC_P_MASK))
2016             raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
2017 #ifdef TARGET_X86_64
2018         if (env->hflags & HF_LMA_MASK) {
2019             uint32_t e3;
2020             e3 = ldl_kernel(ptr + 8);
2021             load_seg_cache_raw_dt(&env->ldt, e1, e2);
2022             env->ldt.base |= (target_ulong)e3 << 32;
2023         } else
2024 #endif
2025         {
2026             load_seg_cache_raw_dt(&env->ldt, e1, e2);
2027         }
2028     }
2029     env->ldt.selector = selector;
2030 }
2031
2032 void helper_ltr(int selector)
2033 {
2034     SegmentCache *dt;
2035     uint32_t e1, e2;
2036     int index, type, entry_limit;
2037     target_ulong ptr;
2038
2039     selector &= 0xffff;
2040     if ((selector & 0xfffc) == 0) {
2041         /* NULL selector case: invalid TR */
2042         env->tr.base = 0;
2043         env->tr.limit = 0;
2044         env->tr.flags = 0;
2045     } else {
2046         if (selector & 0x4)
2047             raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2048         dt = &env->gdt;
2049         index = selector & ~7;
2050 #ifdef TARGET_X86_64
2051         if (env->hflags & HF_LMA_MASK)
2052             entry_limit = 15;
2053         else
2054 #endif
2055             entry_limit = 7;
2056         if ((index + entry_limit) > dt->limit)
2057             raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2058         ptr = dt->base + index;
2059         e1 = ldl_kernel(ptr);
2060         e2 = ldl_kernel(ptr + 4);
2061         type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
2062         if ((e2 & DESC_S_MASK) ||
2063             (type != 1 && type != 9))
2064             raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2065         if (!(e2 & DESC_P_MASK))
2066             raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
2067 #ifdef TARGET_X86_64
2068         if (env->hflags & HF_LMA_MASK) {
2069             uint32_t e3, e4;
2070             e3 = ldl_kernel(ptr + 8);
2071             e4 = ldl_kernel(ptr + 12);
2072             if ((e4 >> DESC_TYPE_SHIFT) & 0xf)
2073                 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2074             load_seg_cache_raw_dt(&env->tr, e1, e2);
2075             env->tr.base |= (target_ulong)e3 << 32;
2076         } else
2077 #endif
2078         {
2079             load_seg_cache_raw_dt(&env->tr, e1, e2);
2080         }
2081         e2 |= DESC_TSS_BUSY_MASK;
2082         stl_kernel(ptr + 4, e2);
2083     }
2084     env->tr.selector = selector;
2085 }
2086
2087 /* only works if protected mode and not VM86. seg_reg must be != R_CS */
2088 void helper_load_seg(int seg_reg, int selector)
2089 {
2090     uint32_t e1, e2;
2091     int cpl, dpl, rpl;
2092     SegmentCache *dt;
2093     int index;
2094     target_ulong ptr;
2095
2096     selector &= 0xffff;
2097     cpl = env->hflags & HF_CPL_MASK;
2098     if ((selector & 0xfffc) == 0) {
2099         /* null selector case */
2100         if (seg_reg == R_SS
2101 #ifdef TARGET_X86_64
2102             && (!(env->hflags & HF_CS64_MASK) || cpl == 3)
2103 #endif
2104             )
2105             raise_exception_err(EXCP0D_GPF, 0);
2106         cpu_x86_load_seg_cache(env, seg_reg, selector, 0, 0, 0);
2107     } else {
2108
2109         if (selector & 0x4)
2110             dt = &env->ldt;
2111         else
2112             dt = &env->gdt;
2113         index = selector & ~7;
2114         if ((index + 7) > dt->limit)
2115             raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2116         ptr = dt->base + index;
2117         e1 = ldl_kernel(ptr);
2118         e2 = ldl_kernel(ptr + 4);
2119
2120         if (!(e2 & DESC_S_MASK))
2121             raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2122         rpl = selector & 3;
2123         dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2124         if (seg_reg == R_SS) {
2125             /* must be writable segment */
2126             if ((e2 & DESC_CS_MASK) || !(e2 & DESC_W_MASK))
2127                 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2128             if (rpl != cpl || dpl != cpl)
2129                 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2130         } else {
2131             /* must be readable segment */
2132             if ((e2 & (DESC_CS_MASK | DESC_R_MASK)) == DESC_CS_MASK)
2133                 raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2134
2135             if (!(e2 & DESC_CS_MASK) || !(e2 & DESC_C_MASK)) {
2136                 /* if not conforming code, test rights */
2137                 if (dpl < cpl || dpl < rpl)
2138                     raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2139             }
2140         }
2141
2142         if (!(e2 & DESC_P_MASK)) {
2143             if (seg_reg == R_SS)
2144                 raise_exception_err(EXCP0C_STACK, selector & 0xfffc);
2145             else
2146                 raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
2147         }
2148
2149         /* set the access bit if not already set */
2150         if (!(e2 & DESC_A_MASK)) {
2151             e2 |= DESC_A_MASK;
2152             stl_kernel(ptr + 4, e2);
2153         }
2154
2155         cpu_x86_load_seg_cache(env, seg_reg, selector,
2156                        get_seg_base(e1, e2),
2157                        get_seg_limit(e1, e2),
2158                        e2);
2159 #if 0
2160         qemu_log("load_seg: sel=0x%04x base=0x%08lx limit=0x%08lx flags=%08x\n",
2161                 selector, (unsigned long)sc->base, sc->limit, sc->flags);
2162 #endif
2163     }
2164 }
2165
2166 /* protected mode jump */
2167 void helper_ljmp_protected(int new_cs, target_ulong new_eip,
2168                            int next_eip_addend)
2169 {
2170     int gate_cs, type;
2171     uint32_t e1, e2, cpl, dpl, rpl, limit;
2172     target_ulong next_eip;
2173
2174     if ((new_cs & 0xfffc) == 0)
2175         raise_exception_err(EXCP0D_GPF, 0);
2176     if (load_segment(&e1, &e2, new_cs) != 0)
2177         raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2178     cpl = env->hflags & HF_CPL_MASK;
2179     if (e2 & DESC_S_MASK) {
2180         if (!(e2 & DESC_CS_MASK))
2181             raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2182         dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2183         if (e2 & DESC_C_MASK) {
2184             /* conforming code segment */
2185             if (dpl > cpl)
2186                 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2187         } else {
2188             /* non conforming code segment */
2189             rpl = new_cs & 3;
2190             if (rpl > cpl)
2191                 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2192             if (dpl != cpl)
2193                 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2194         }
2195         if (!(e2 & DESC_P_MASK))
2196             raise_exception_err(EXCP0B_NOSEG, new_cs & 0xfffc);
2197         limit = get_seg_limit(e1, e2);
2198         if (new_eip > limit &&
2199             !(env->hflags & HF_LMA_MASK) && !(e2 & DESC_L_MASK))
2200             raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2201         cpu_x86_load_seg_cache(env, R_CS, (new_cs & 0xfffc) | cpl,
2202                        get_seg_base(e1, e2), limit, e2);
2203         EIP = new_eip;
2204     } else {
2205         /* jump to call or task gate */
2206         dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2207         rpl = new_cs & 3;
2208         cpl = env->hflags & HF_CPL_MASK;
2209         type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
2210         switch(type) {
2211         case 1: /* 286 TSS */
2212         case 9: /* 386 TSS */
2213         case 5: /* task gate */
2214             if (dpl < cpl || dpl < rpl)
2215                 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2216             next_eip = env->eip + next_eip_addend;
2217             switch_tss(new_cs, e1, e2, SWITCH_TSS_JMP, next_eip);
2218             CC_OP = CC_OP_EFLAGS;
2219             break;
2220         case 4: /* 286 call gate */
2221         case 12: /* 386 call gate */
2222             if ((dpl < cpl) || (dpl < rpl))
2223                 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2224             if (!(e2 & DESC_P_MASK))
2225                 raise_exception_err(EXCP0B_NOSEG, new_cs & 0xfffc);
2226             gate_cs = e1 >> 16;
2227             new_eip = (e1 & 0xffff);
2228             if (type == 12)
2229                 new_eip |= (e2 & 0xffff0000);
2230             if (load_segment(&e1, &e2, gate_cs) != 0)
2231                 raise_exception_err(EXCP0D_GPF, gate_cs & 0xfffc);
2232             dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2233             /* must be code segment */
2234             if (((e2 & (DESC_S_MASK | DESC_CS_MASK)) !=
2235                  (DESC_S_MASK | DESC_CS_MASK)))
2236                 raise_exception_err(EXCP0D_GPF, gate_cs & 0xfffc);
2237             if (((e2 & DESC_C_MASK) && (dpl > cpl)) ||
2238                 (!(e2 & DESC_C_MASK) && (dpl != cpl)))
2239                 raise_exception_err(EXCP0D_GPF, gate_cs & 0xfffc);
2240             if (!(e2 & DESC_P_MASK))
2241                 raise_exception_err(EXCP0D_GPF, gate_cs & 0xfffc);
2242             limit = get_seg_limit(e1, e2);
2243             if (new_eip > limit)
2244                 raise_exception_err(EXCP0D_GPF, 0);
2245             cpu_x86_load_seg_cache(env, R_CS, (gate_cs & 0xfffc) | cpl,
2246                                    get_seg_base(e1, e2), limit, e2);
2247             EIP = new_eip;
2248             break;
2249         default:
2250             raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2251             break;
2252         }
2253     }
2254 }
2255
2256 /* real mode call */
2257 void helper_lcall_real(int new_cs, target_ulong new_eip1,
2258                        int shift, int next_eip)
2259 {
2260     int new_eip;
2261     uint32_t esp, esp_mask;
2262     target_ulong ssp;
2263
2264     new_eip = new_eip1;
2265     esp = ESP;
2266     esp_mask = get_sp_mask(env->segs[R_SS].flags);
2267     ssp = env->segs[R_SS].base;
2268     if (shift) {
2269         PUSHL(ssp, esp, esp_mask, env->segs[R_CS].selector);
2270         PUSHL(ssp, esp, esp_mask, next_eip);
2271     } else {
2272         PUSHW(ssp, esp, esp_mask, env->segs[R_CS].selector);
2273         PUSHW(ssp, esp, esp_mask, next_eip);
2274     }
2275
2276     SET_ESP(esp, esp_mask);
2277     env->eip = new_eip;
2278     env->segs[R_CS].selector = new_cs;
2279     env->segs[R_CS].base = (new_cs << 4);
2280 }
2281
2282 /* protected mode call */
2283 void helper_lcall_protected(int new_cs, target_ulong new_eip,
2284                             int shift, int next_eip_addend)
2285 {
2286     int new_stack, i;
2287     uint32_t e1, e2, cpl, dpl, rpl, selector, offset, param_count;
2288     uint32_t ss = 0, ss_e1 = 0, ss_e2 = 0, sp, type, ss_dpl, sp_mask;
2289     uint32_t val, limit, old_sp_mask;
2290     target_ulong ssp, old_ssp, next_eip;
2291
2292     next_eip = env->eip + next_eip_addend;
2293     LOG_PCALL("lcall %04x:%08x s=%d\n", new_cs, (uint32_t)new_eip, shift);
2294     LOG_PCALL_STATE(env);
2295     if ((new_cs & 0xfffc) == 0)
2296         raise_exception_err(EXCP0D_GPF, 0);
2297     if (load_segment(&e1, &e2, new_cs) != 0)
2298         raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2299     cpl = env->hflags & HF_CPL_MASK;
2300     LOG_PCALL("desc=%08x:%08x\n", e1, e2);
2301     if (e2 & DESC_S_MASK) {
2302         if (!(e2 & DESC_CS_MASK))
2303             raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2304         dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2305         if (e2 & DESC_C_MASK) {
2306             /* conforming code segment */
2307             if (dpl > cpl)
2308                 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2309         } else {
2310             /* non conforming code segment */
2311             rpl = new_cs & 3;
2312             if (rpl > cpl)
2313                 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2314             if (dpl != cpl)
2315                 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2316         }
2317         if (!(e2 & DESC_P_MASK))
2318             raise_exception_err(EXCP0B_NOSEG, new_cs & 0xfffc);
2319
2320 #ifdef TARGET_X86_64
2321         /* XXX: check 16/32 bit cases in long mode */
2322         if (shift == 2) {
2323             target_ulong rsp;
2324             /* 64 bit case */
2325             rsp = ESP;
2326             PUSHQ(rsp, env->segs[R_CS].selector);
2327             PUSHQ(rsp, next_eip);
2328             /* from this point, not restartable */
2329             ESP = rsp;
2330             cpu_x86_load_seg_cache(env, R_CS, (new_cs & 0xfffc) | cpl,
2331                                    get_seg_base(e1, e2),
2332                                    get_seg_limit(e1, e2), e2);
2333             EIP = new_eip;
2334         } else
2335 #endif
2336         {
2337             sp = ESP;
2338             sp_mask = get_sp_mask(env->segs[R_SS].flags);
2339             ssp = env->segs[R_SS].base;
2340             if (shift) {
2341                 PUSHL(ssp, sp, sp_mask, env->segs[R_CS].selector);
2342                 PUSHL(ssp, sp, sp_mask, next_eip);
2343             } else {
2344                 PUSHW(ssp, sp, sp_mask, env->segs[R_CS].selector);
2345                 PUSHW(ssp, sp, sp_mask, next_eip);
2346             }
2347
2348             limit = get_seg_limit(e1, e2);
2349             if (new_eip > limit)
2350                 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2351             /* from this point, not restartable */
2352             SET_ESP(sp, sp_mask);
2353             cpu_x86_load_seg_cache(env, R_CS, (new_cs & 0xfffc) | cpl,
2354                                    get_seg_base(e1, e2), limit, e2);
2355             EIP = new_eip;
2356         }
2357     } else {
2358         /* check gate type */
2359         type = (e2 >> DESC_TYPE_SHIFT) & 0x1f;
2360         dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2361         rpl = new_cs & 3;
2362         switch(type) {
2363         case 1: /* available 286 TSS */
2364         case 9: /* available 386 TSS */
2365         case 5: /* task gate */
2366             if (dpl < cpl || dpl < rpl)
2367                 raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2368             switch_tss(new_cs, e1, e2, SWITCH_TSS_CALL, next_eip);
2369             CC_OP = CC_OP_EFLAGS;
2370             return;
2371         case 4: /* 286 call gate */
2372         case 12: /* 386 call gate */
2373             break;
2374         default:
2375             raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2376             break;
2377         }
2378         shift = type >> 3;
2379
2380         if (dpl < cpl || dpl < rpl)
2381             raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2382         /* check valid bit */
2383         if (!(e2 & DESC_P_MASK))
2384             raise_exception_err(EXCP0B_NOSEG,  new_cs & 0xfffc);
2385         selector = e1 >> 16;
2386         offset = (e2 & 0xffff0000) | (e1 & 0x0000ffff);
2387         param_count = e2 & 0x1f;
2388         if ((selector & 0xfffc) == 0)
2389             raise_exception_err(EXCP0D_GPF, 0);
2390
2391         if (load_segment(&e1, &e2, selector) != 0)
2392             raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2393         if (!(e2 & DESC_S_MASK) || !(e2 & (DESC_CS_MASK)))
2394             raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2395         dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2396         if (dpl > cpl)
2397             raise_exception_err(EXCP0D_GPF, selector & 0xfffc);
2398         if (!(e2 & DESC_P_MASK))
2399             raise_exception_err(EXCP0B_NOSEG, selector & 0xfffc);
2400
2401         if (!(e2 & DESC_C_MASK) && dpl < cpl) {
2402             /* to inner privilege */
2403             get_ss_esp_from_tss(&ss, &sp, dpl);
2404             LOG_PCALL("new ss:esp=%04x:%08x param_count=%d ESP=" TARGET_FMT_lx "\n",
2405                         ss, sp, param_count, ESP);
2406             if ((ss & 0xfffc) == 0)
2407                 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2408             if ((ss & 3) != dpl)
2409                 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2410             if (load_segment(&ss_e1, &ss_e2, ss) != 0)
2411                 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2412             ss_dpl = (ss_e2 >> DESC_DPL_SHIFT) & 3;
2413             if (ss_dpl != dpl)
2414                 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2415             if (!(ss_e2 & DESC_S_MASK) ||
2416                 (ss_e2 & DESC_CS_MASK) ||
2417                 !(ss_e2 & DESC_W_MASK))
2418                 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2419             if (!(ss_e2 & DESC_P_MASK))
2420                 raise_exception_err(EXCP0A_TSS, ss & 0xfffc);
2421
2422             //            push_size = ((param_count * 2) + 8) << shift;
2423
2424             old_sp_mask = get_sp_mask(env->segs[R_SS].flags);
2425             old_ssp = env->segs[R_SS].base;
2426
2427             sp_mask = get_sp_mask(ss_e2);
2428             ssp = get_seg_base(ss_e1, ss_e2);
2429             if (shift) {
2430                 PUSHL(ssp, sp, sp_mask, env->segs[R_SS].selector);
2431                 PUSHL(ssp, sp, sp_mask, ESP);
2432                 for(i = param_count - 1; i >= 0; i--) {
2433                     val = ldl_kernel(old_ssp + ((ESP + i * 4) & old_sp_mask));
2434                     PUSHL(ssp, sp, sp_mask, val);
2435                 }
2436             } else {
2437                 PUSHW(ssp, sp, sp_mask, env->segs[R_SS].selector);
2438                 PUSHW(ssp, sp, sp_mask, ESP);
2439                 for(i = param_count - 1; i >= 0; i--) {
2440                     val = lduw_kernel(old_ssp + ((ESP + i * 2) & old_sp_mask));
2441                     PUSHW(ssp, sp, sp_mask, val);
2442                 }
2443             }
2444             new_stack = 1;
2445         } else {
2446             /* to same privilege */
2447             sp = ESP;
2448             sp_mask = get_sp_mask(env->segs[R_SS].flags);
2449             ssp = env->segs[R_SS].base;
2450             //            push_size = (4 << shift);
2451             new_stack = 0;
2452         }
2453
2454         if (shift) {
2455             PUSHL(ssp, sp, sp_mask, env->segs[R_CS].selector);
2456             PUSHL(ssp, sp, sp_mask, next_eip);
2457         } else {
2458             PUSHW(ssp, sp, sp_mask, env->segs[R_CS].selector);
2459             PUSHW(ssp, sp, sp_mask, next_eip);
2460         }
2461
2462         /* from this point, not restartable */
2463
2464         if (new_stack) {
2465             ss = (ss & ~3) | dpl;
2466             cpu_x86_load_seg_cache(env, R_SS, ss,
2467                                    ssp,
2468                                    get_seg_limit(ss_e1, ss_e2),
2469                                    ss_e2);
2470         }
2471
2472         selector = (selector & ~3) | dpl;
2473         cpu_x86_load_seg_cache(env, R_CS, selector,
2474                        get_seg_base(e1, e2),
2475                        get_seg_limit(e1, e2),
2476                        e2);
2477         cpu_x86_set_cpl(env, dpl);
2478         SET_ESP(sp, sp_mask);
2479         EIP = offset;
2480     }
2481 #ifdef USE_KQEMU
2482     if (kqemu_is_ok(env)) {
2483         env->exception_index = -1;
2484         cpu_loop_exit();
2485     }
2486 #endif
2487 }
2488
2489 /* real and vm86 mode iret */
2490 void helper_iret_real(int shift)
2491 {
2492     uint32_t sp, new_cs, new_eip, new_eflags, sp_mask;
2493     target_ulong ssp;
2494     int eflags_mask;
2495
2496     sp_mask = 0xffff; /* XXXX: use SS segment size ? */
2497     sp = ESP;
2498     ssp = env->segs[R_SS].base;
2499     if (shift == 1) {
2500         /* 32 bits */
2501         POPL(ssp, sp, sp_mask, new_eip);
2502         POPL(ssp, sp, sp_mask, new_cs);
2503         new_cs &= 0xffff;
2504         POPL(ssp, sp, sp_mask, new_eflags);
2505     } else {
2506         /* 16 bits */
2507         POPW(ssp, sp, sp_mask, new_eip);
2508         POPW(ssp, sp, sp_mask, new_cs);
2509         POPW(ssp, sp, sp_mask, new_eflags);
2510     }
2511     ESP = (ESP & ~sp_mask) | (sp & sp_mask);
2512     env->segs[R_CS].selector = new_cs;
2513     env->segs[R_CS].base = (new_cs << 4);
2514     env->eip = new_eip;
2515     if (env->eflags & VM_MASK)
2516         eflags_mask = TF_MASK | AC_MASK | ID_MASK | IF_MASK | RF_MASK | NT_MASK;
2517     else
2518         eflags_mask = TF_MASK | AC_MASK | ID_MASK | IF_MASK | IOPL_MASK | RF_MASK | NT_MASK;
2519     if (shift == 0)
2520         eflags_mask &= 0xffff;
2521     load_eflags(new_eflags, eflags_mask);
2522     env->hflags2 &= ~HF2_NMI_MASK;
2523 }
2524
2525 static inline void validate_seg(int seg_reg, int cpl)
2526 {
2527     int dpl;
2528     uint32_t e2;
2529
2530     /* XXX: on x86_64, we do not want to nullify FS and GS because
2531        they may still contain a valid base. I would be interested to
2532        know how a real x86_64 CPU behaves */
2533     if ((seg_reg == R_FS || seg_reg == R_GS) &&
2534         (env->segs[seg_reg].selector & 0xfffc) == 0)
2535         return;
2536
2537     e2 = env->segs[seg_reg].flags;
2538     dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2539     if (!(e2 & DESC_CS_MASK) || !(e2 & DESC_C_MASK)) {
2540         /* data or non conforming code segment */
2541         if (dpl < cpl) {
2542             cpu_x86_load_seg_cache(env, seg_reg, 0, 0, 0, 0);
2543         }
2544     }
2545 }
2546
2547 /* protected mode iret */
2548 static inline void helper_ret_protected(int shift, int is_iret, int addend)
2549 {
2550     uint32_t new_cs, new_eflags, new_ss;
2551     uint32_t new_es, new_ds, new_fs, new_gs;
2552     uint32_t e1, e2, ss_e1, ss_e2;
2553     int cpl, dpl, rpl, eflags_mask, iopl;
2554     target_ulong ssp, sp, new_eip, new_esp, sp_mask;
2555
2556 #ifdef TARGET_X86_64
2557     if (shift == 2)
2558         sp_mask = -1;
2559     else
2560 #endif
2561         sp_mask = get_sp_mask(env->segs[R_SS].flags);
2562     sp = ESP;
2563     ssp = env->segs[R_SS].base;
2564     new_eflags = 0; /* avoid warning */
2565 #ifdef TARGET_X86_64
2566     if (shift == 2) {
2567         POPQ(sp, new_eip);
2568         POPQ(sp, new_cs);
2569         new_cs &= 0xffff;
2570         if (is_iret) {
2571             POPQ(sp, new_eflags);
2572         }
2573     } else
2574 #endif
2575     if (shift == 1) {
2576         /* 32 bits */
2577         POPL(ssp, sp, sp_mask, new_eip);
2578         POPL(ssp, sp, sp_mask, new_cs);
2579         new_cs &= 0xffff;
2580         if (is_iret) {
2581             POPL(ssp, sp, sp_mask, new_eflags);
2582             if (new_eflags & VM_MASK)
2583                 goto return_to_vm86;
2584         }
2585     } else {
2586         /* 16 bits */
2587         POPW(ssp, sp, sp_mask, new_eip);
2588         POPW(ssp, sp, sp_mask, new_cs);
2589         if (is_iret)
2590             POPW(ssp, sp, sp_mask, new_eflags);
2591     }
2592     LOG_PCALL("lret new %04x:" TARGET_FMT_lx " s=%d addend=0x%x\n",
2593               new_cs, new_eip, shift, addend);
2594     LOG_PCALL_STATE(env);
2595     if ((new_cs & 0xfffc) == 0)
2596         raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2597     if (load_segment(&e1, &e2, new_cs) != 0)
2598         raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2599     if (!(e2 & DESC_S_MASK) ||
2600         !(e2 & DESC_CS_MASK))
2601         raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2602     cpl = env->hflags & HF_CPL_MASK;
2603     rpl = new_cs & 3;
2604     if (rpl < cpl)
2605         raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2606     dpl = (e2 >> DESC_DPL_SHIFT) & 3;
2607     if (e2 & DESC_C_MASK) {
2608         if (dpl > rpl)
2609             raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2610     } else {
2611         if (dpl != rpl)
2612             raise_exception_err(EXCP0D_GPF, new_cs & 0xfffc);
2613     }
2614     if (!(e2 & DESC_P_MASK))
2615         raise_exception_err(EXCP0B_NOSEG, new_cs & 0xfffc);
2616
2617     sp += addend;
2618     if (rpl == cpl && (!(env->hflags & HF_CS64_MASK) ||
2619                        ((env->hflags & HF_CS64_MASK) && !is_iret))) {
2620         /* return to same privilege level */
2621         cpu_x86_load_seg_cache(env, R_CS, new_cs,
2622                        get_seg_base(e1, e2),
2623                        get_seg_limit(e1, e2),
2624                        e2);
2625     } else {
2626         /* return to different privilege level */
2627 #ifdef TARGET_X86_64
2628         if (shift == 2) {
2629             POPQ(sp, new_esp);
2630             POPQ(sp, new_ss);
2631             new_ss &= 0xffff;
2632         } else
2633 #endif
2634         if (shift == 1) {
2635             /* 32 bits */
2636             POPL(ssp, sp, sp_mask, new_esp);
2637             POPL(ssp, sp, sp_mask, new_ss);
2638             new_ss &= 0xffff;
2639         } else {
2640             /* 16 bits */
2641             POPW(ssp, sp, sp_mask, new_esp);
2642             POPW(ssp, sp, sp_mask, new_ss);
2643         }
2644         LOG_PCALL("new ss:esp=%04x:" TARGET_FMT_lx "\n",
2645                     new_ss, new_esp);
2646         if ((new_ss & 0xfffc) == 0) {
2647 #ifdef TARGET_X86_64
2648             /* NULL ss is allowed in long mode if cpl != 3*/
2649             /* XXX: test CS64 ? */
2650             if ((env->hflags & HF_LMA_MASK) && rpl != 3) {
2651                 cpu_x86_load_seg_cache(env, R_SS, new_ss,
2652                                        0, 0xffffffff,
2653                                        DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2654                                        DESC_S_MASK | (rpl << DESC_DPL_SHIFT) |
2655                                        DESC_W_MASK | DESC_A_MASK);
2656                 ss_e2 = DESC_B_MASK; /* XXX: should not be needed ? */
2657             } else
2658 #endif
2659             {
2660                 raise_exception_err(EXCP0D_GPF, 0);
2661             }
2662         } else {
2663             if ((new_ss & 3) != rpl)
2664                 raise_exception_err(EXCP0D_GPF, new_ss & 0xfffc);
2665             if (load_segment(&ss_e1, &ss_e2, new_ss) != 0)
2666                 raise_exception_err(EXCP0D_GPF, new_ss & 0xfffc);
2667             if (!(ss_e2 & DESC_S_MASK) ||
2668                 (ss_e2 & DESC_CS_MASK) ||
2669                 !(ss_e2 & DESC_W_MASK))
2670                 raise_exception_err(EXCP0D_GPF, new_ss & 0xfffc);
2671             dpl = (ss_e2 >> DESC_DPL_SHIFT) & 3;
2672             if (dpl != rpl)
2673                 raise_exception_err(EXCP0D_GPF, new_ss & 0xfffc);
2674             if (!(ss_e2 & DESC_P_MASK))
2675                 raise_exception_err(EXCP0B_NOSEG, new_ss & 0xfffc);
2676             cpu_x86_load_seg_cache(env, R_SS, new_ss,
2677                                    get_seg_base(ss_e1, ss_e2),
2678                                    get_seg_limit(ss_e1, ss_e2),
2679                                    ss_e2);
2680         }
2681
2682         cpu_x86_load_seg_cache(env, R_CS, new_cs,
2683                        get_seg_base(e1, e2),
2684                        get_seg_limit(e1, e2),
2685                        e2);
2686         cpu_x86_set_cpl(env, rpl);
2687         sp = new_esp;
2688 #ifdef TARGET_X86_64
2689         if (env->hflags & HF_CS64_MASK)
2690             sp_mask = -1;
2691         else
2692 #endif
2693             sp_mask = get_sp_mask(ss_e2);
2694
2695         /* validate data segments */
2696         validate_seg(R_ES, rpl);
2697         validate_seg(R_DS, rpl);
2698         validate_seg(R_FS, rpl);
2699         validate_seg(R_GS, rpl);
2700
2701         sp += addend;
2702     }
2703     SET_ESP(sp, sp_mask);
2704     env->eip = new_eip;
2705     if (is_iret) {
2706         /* NOTE: 'cpl' is the _old_ CPL */
2707         eflags_mask = TF_MASK | AC_MASK | ID_MASK | RF_MASK | NT_MASK;
2708         if (cpl == 0)
2709             eflags_mask |= IOPL_MASK;
2710         iopl = (env->eflags >> IOPL_SHIFT) & 3;
2711         if (cpl <= iopl)
2712             eflags_mask |= IF_MASK;
2713         if (shift == 0)
2714             eflags_mask &= 0xffff;
2715         load_eflags(new_eflags, eflags_mask);
2716     }
2717     return;
2718
2719  return_to_vm86:
2720     POPL(ssp, sp, sp_mask, new_esp);
2721     POPL(ssp, sp, sp_mask, new_ss);
2722     POPL(ssp, sp, sp_mask, new_es);
2723     POPL(ssp, sp, sp_mask, new_ds);
2724     POPL(ssp, sp, sp_mask, new_fs);
2725     POPL(ssp, sp, sp_mask, new_gs);
2726
2727     /* modify processor state */
2728     load_eflags(new_eflags, TF_MASK | AC_MASK | ID_MASK |
2729                 IF_MASK | IOPL_MASK | VM_MASK | NT_MASK | VIF_MASK | VIP_MASK);
2730     load_seg_vm(R_CS, new_cs & 0xffff);
2731     cpu_x86_set_cpl(env, 3);
2732     load_seg_vm(R_SS, new_ss & 0xffff);
2733     load_seg_vm(R_ES, new_es & 0xffff);
2734     load_seg_vm(R_DS, new_ds & 0xffff);
2735     load_seg_vm(R_FS, new_fs & 0xffff);
2736     load_seg_vm(R_GS, new_gs & 0xffff);
2737
2738     env->eip = new_eip & 0xffff;
2739     ESP = new_esp;
2740 }
2741
2742 void helper_iret_protected(int shift, int next_eip)
2743 {
2744     int tss_selector, type;
2745     uint32_t e1, e2;
2746
2747     /* specific case for TSS */
2748     if (env->eflags & NT_MASK) {
2749 #ifdef TARGET_X86_64
2750         if (env->hflags & HF_LMA_MASK)
2751             raise_exception_err(EXCP0D_GPF, 0);
2752 #endif
2753         tss_selector = lduw_kernel(env->tr.base + 0);
2754         if (tss_selector & 4)
2755             raise_exception_err(EXCP0A_TSS, tss_selector & 0xfffc);
2756         if (load_segment(&e1, &e2, tss_selector) != 0)
2757             raise_exception_err(EXCP0A_TSS, tss_selector & 0xfffc);
2758         type = (e2 >> DESC_TYPE_SHIFT) & 0x17;
2759         /* NOTE: we check both segment and busy TSS */
2760         if (type != 3)
2761             raise_exception_err(EXCP0A_TSS, tss_selector & 0xfffc);
2762         switch_tss(tss_selector, e1, e2, SWITCH_TSS_IRET, next_eip);
2763     } else {
2764         helper_ret_protected(shift, 1, 0);
2765     }
2766     env->hflags2 &= ~HF2_NMI_MASK;
2767 #ifdef USE_KQEMU
2768     if (kqemu_is_ok(env)) {
2769         CC_OP = CC_OP_EFLAGS;
2770         env->exception_index = -1;
2771         cpu_loop_exit();
2772     }
2773 #endif
2774 }
2775
2776 void helper_lret_protected(int shift, int addend)
2777 {
2778     helper_ret_protected(shift, 0, addend);
2779 #ifdef USE_KQEMU
2780     if (kqemu_is_ok(env)) {
2781         env->exception_index = -1;
2782         cpu_loop_exit();
2783     }
2784 #endif
2785 }
2786
2787 void helper_sysenter(void)
2788 {
2789     if (env->sysenter_cs == 0) {
2790         raise_exception_err(EXCP0D_GPF, 0);
2791     }
2792     env->eflags &= ~(VM_MASK | IF_MASK | RF_MASK);
2793     cpu_x86_set_cpl(env, 0);
2794
2795 #ifdef TARGET_X86_64
2796     if (env->hflags & HF_LMA_MASK) {
2797         cpu_x86_load_seg_cache(env, R_CS, env->sysenter_cs & 0xfffc,
2798                                0, 0xffffffff,
2799                                DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2800                                DESC_S_MASK |
2801                                DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK | DESC_L_MASK);
2802     } else
2803 #endif
2804     {
2805         cpu_x86_load_seg_cache(env, R_CS, env->sysenter_cs & 0xfffc,
2806                                0, 0xffffffff,
2807                                DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2808                                DESC_S_MASK |
2809                                DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);
2810     }
2811     cpu_x86_load_seg_cache(env, R_SS, (env->sysenter_cs + 8) & 0xfffc,
2812                            0, 0xffffffff,
2813                            DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2814                            DESC_S_MASK |
2815                            DESC_W_MASK | DESC_A_MASK);
2816     ESP = env->sysenter_esp;
2817     EIP = env->sysenter_eip;
2818 }
2819
2820 void helper_sysexit(int dflag)
2821 {
2822     int cpl;
2823
2824     cpl = env->hflags & HF_CPL_MASK;
2825     if (env->sysenter_cs == 0 || cpl != 0) {
2826         raise_exception_err(EXCP0D_GPF, 0);
2827     }
2828     cpu_x86_set_cpl(env, 3);
2829 #ifdef TARGET_X86_64
2830     if (dflag == 2) {
2831         cpu_x86_load_seg_cache(env, R_CS, ((env->sysenter_cs + 32) & 0xfffc) | 3,
2832                                0, 0xffffffff,
2833                                DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2834                                DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
2835                                DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK | DESC_L_MASK);
2836         cpu_x86_load_seg_cache(env, R_SS, ((env->sysenter_cs + 40) & 0xfffc) | 3,
2837                                0, 0xffffffff,
2838                                DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2839                                DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
2840                                DESC_W_MASK | DESC_A_MASK);
2841     } else
2842 #endif
2843     {
2844         cpu_x86_load_seg_cache(env, R_CS, ((env->sysenter_cs + 16) & 0xfffc) | 3,
2845                                0, 0xffffffff,
2846                                DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2847                                DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
2848                                DESC_CS_MASK | DESC_R_MASK | DESC_A_MASK);
2849         cpu_x86_load_seg_cache(env, R_SS, ((env->sysenter_cs + 24) & 0xfffc) | 3,
2850                                0, 0xffffffff,
2851                                DESC_G_MASK | DESC_B_MASK | DESC_P_MASK |
2852                                DESC_S_MASK | (3 << DESC_DPL_SHIFT) |
2853                                DESC_W_MASK | DESC_A_MASK);
2854     }
2855     ESP = ECX;
2856     EIP = EDX;
2857 #ifdef USE_KQEMU
2858     if (kqemu_is_ok(env)) {
2859         env->exception_index = -1;
2860         cpu_loop_exit();
2861     }
2862 #endif
2863 }
2864
2865 #if defined(CONFIG_USER_ONLY)
2866 target_ulong helper_read_crN(int reg)
2867 {
2868     return 0;
2869 }
2870
2871 void helper_write_crN(int reg, target_ulong t0)
2872 {
2873 }
2874
2875 void helper_movl_drN_T0(int reg, target_ulong t0)
2876 {
2877 }
2878 #else
2879 target_ulong helper_read_crN(int reg)
2880 {
2881     target_ulong val;
2882
2883     helper_svm_check_intercept_param(SVM_EXIT_READ_CR0 + reg, 0);
2884     switch(reg) {
2885     default:
2886         val = env->cr[reg];
2887         break;
2888     case 8:
2889         if (!(env->hflags2 & HF2_VINTR_MASK)) {
2890             val = cpu_get_apic_tpr(env);
2891         } else {
2892             val = env->v_tpr;
2893         }
2894         break;
2895     }
2896     return val;
2897 }
2898
2899 void helper_write_crN(int reg, target_ulong t0)
2900 {
2901     helper_svm_check_intercept_param(SVM_EXIT_WRITE_CR0 + reg, 0);
2902     switch(reg) {
2903     case 0:
2904         cpu_x86_update_cr0(env, t0);
2905         break;
2906     case 3:
2907         cpu_x86_update_cr3(env, t0);
2908         break;
2909     case 4:
2910         cpu_x86_update_cr4(env, t0);
2911         break;
2912     case 8:
2913         if (!(env->hflags2 & HF2_VINTR_MASK)) {
2914             cpu_set_apic_tpr(env, t0);
2915         }
2916         env->v_tpr = t0 & 0x0f;
2917         break;
2918     default:
2919         env->cr[reg] = t0;
2920         break;
2921     }
2922 }
2923
2924 void helper_movl_drN_T0(int reg, target_ulong t0)
2925 {
2926     int i;
2927
2928     if (reg < 4) {
2929         hw_breakpoint_remove(env, reg);
2930         env->dr[reg] = t0;
2931         hw_breakpoint_insert(env, reg);
2932     } else if (reg == 7) {
2933         for (i = 0; i < 4; i++)
2934             hw_breakpoint_remove(env, i);
2935         env->dr[7] = t0;
2936         for (i = 0; i < 4; i++)
2937             hw_breakpoint_insert(env, i);
2938     } else
2939         env->dr[reg] = t0;
2940 }
2941 #endif
2942
2943 void helper_lmsw(target_ulong t0)
2944 {
2945     /* only 4 lower bits of CR0 are modified. PE cannot be set to zero
2946        if already set to one. */
2947     t0 = (env->cr[0] & ~0xe) | (t0 & 0xf);
2948     helper_write_crN(0, t0);
2949 }
2950
2951 void helper_clts(void)
2952 {
2953     env->cr[0] &= ~CR0_TS_MASK;
2954     env->hflags &= ~HF_TS_MASK;
2955 }
2956
2957 void helper_invlpg(target_ulong addr)
2958 {
2959     helper_svm_check_intercept_param(SVM_EXIT_INVLPG, 0);
2960     tlb_flush_page(env, addr);
2961 }
2962
2963 void helper_rdtsc(void)
2964 {
2965     uint64_t val;
2966
2967     if ((env->cr[4] & CR4_TSD_MASK) && ((env->hflags & HF_CPL_MASK) != 0)) {
2968         raise_exception(EXCP0D_GPF);
2969     }
2970     helper_svm_check_intercept_param(SVM_EXIT_RDTSC, 0);
2971
2972     val = cpu_get_tsc(env) + env->tsc_offset;
2973     EAX = (uint32_t)(val);
2974     EDX = (uint32_t)(val >> 32);
2975 }
2976
2977 void helper_rdpmc(void)
2978 {
2979     if ((env->cr[4] & CR4_PCE_MASK) && ((env->hflags & HF_CPL_MASK) != 0)) {
2980         raise_exception(EXCP0D_GPF);
2981     }
2982     helper_svm_check_intercept_param(SVM_EXIT_RDPMC, 0);
2983
2984     /* currently unimplemented */
2985     raise_exception_err(EXCP06_ILLOP, 0);
2986 }
2987
2988 #if defined(CONFIG_USER_ONLY)
2989 void helper_wrmsr(void)
2990 {
2991 }
2992
2993 void helper_rdmsr(void)
2994 {
2995 }
2996 #else
2997 void helper_wrmsr(void)
2998 {
2999     uint64_t val;
3000
3001     helper_svm_check_intercept_param(SVM_EXIT_MSR, 1);
3002
3003     val = ((uint32_t)EAX) | ((uint64_t)((uint32_t)EDX) << 32);
3004
3005     switch((uint32_t)ECX) {
3006     case MSR_IA32_SYSENTER_CS:
3007         env->sysenter_cs = val & 0xffff;
3008         break;
3009     case MSR_IA32_SYSENTER_ESP:
3010         env->sysenter_esp = val;
3011         break;
3012     case MSR_IA32_SYSENTER_EIP:
3013         env->sysenter_eip = val;
3014         break;
3015     case MSR_IA32_APICBASE:
3016         cpu_set_apic_base(env, val);
3017         break;
3018     case MSR_EFER:
3019         {
3020             uint64_t update_mask;
3021             update_mask = 0;
3022             if (env->cpuid_ext2_features & CPUID_EXT2_SYSCALL)
3023                 update_mask |= MSR_EFER_SCE;
3024             if (env->cpuid_ext2_features & CPUID_EXT2_LM)
3025                 update_mask |= MSR_EFER_LME;
3026             if (env->cpuid_ext2_features & CPUID_EXT2_FFXSR)
3027                 update_mask |= MSR_EFER_FFXSR;
3028             if (env->cpuid_ext2_features & CPUID_EXT2_NX)
3029                 update_mask |= MSR_EFER_NXE;
3030             if (env->cpuid_ext3_features & CPUID_EXT3_SVM)
3031                 update_mask |= MSR_EFER_SVME;
3032             if (env->cpuid_ext2_features & CPUID_EXT2_FFXSR)
3033                 update_mask |= MSR_EFER_FFXSR;
3034             cpu_load_efer(env, (env->efer & ~update_mask) |
3035                           (val & update_mask));
3036         }
3037         break;
3038     case MSR_STAR:
3039         env->star = val;
3040         break;
3041     case MSR_PAT:
3042         env->pat = val;
3043         break;
3044     case MSR_VM_HSAVE_PA:
3045         env->vm_hsave = val;
3046         break;
3047 #ifdef TARGET_X86_64
3048     case MSR_LSTAR:
3049         env->lstar = val;
3050         break;
3051     case MSR_CSTAR:
3052         env->cstar = val;
3053         break;
3054     case MSR_FMASK:
3055         env->fmask = val;
3056         break;
3057     case MSR_FSBASE:
3058         env->segs[R_FS].base = val;
3059         break;
3060     case MSR_GSBASE:
3061         env->segs[R_GS].base = val;
3062         break;
3063     case MSR_KERNELGSBASE:
3064         env->kernelgsbase = val;
3065         break;
3066 #endif
3067     case MSR_MTRRphysBase(0):
3068     case MSR_MTRRphysBase(1):
3069     case MSR_MTRRphysBase(2):
3070     case MSR_MTRRphysBase(3):
3071     case MSR_MTRRphysBase(4):
3072     case MSR_MTRRphysBase(5):
3073     case MSR_MTRRphysBase(6):
3074     case MSR_MTRRphysBase(7):
3075         env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysBase(0)) / 2].base = val;
3076         break;
3077     case MSR_MTRRphysMask(0):
3078     case MSR_MTRRphysMask(1):
3079     case MSR_MTRRphysMask(2):
3080     case MSR_MTRRphysMask(3):
3081     case MSR_MTRRphysMask(4):
3082     case MSR_MTRRphysMask(5):
3083     case MSR_MTRRphysMask(6):
3084     case MSR_MTRRphysMask(7):
3085         env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysMask(0)) / 2].mask = val;
3086         break;
3087     case MSR_MTRRfix64K_00000:
3088         env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix64K_00000] = val;
3089         break;
3090     case MSR_MTRRfix16K_80000:
3091     case MSR_MTRRfix16K_A0000:
3092         env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix16K_80000 + 1] = val;
3093         break;
3094     case MSR_MTRRfix4K_C0000:
3095     case MSR_MTRRfix4K_C8000:
3096     case MSR_MTRRfix4K_D0000:
3097     case MSR_MTRRfix4K_D8000:
3098     case MSR_MTRRfix4K_E0000:
3099     case MSR_MTRRfix4K_E8000:
3100     case MSR_MTRRfix4K_F0000:
3101     case MSR_MTRRfix4K_F8000:
3102         env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix4K_C0000 + 3] = val;
3103         break;
3104     case MSR_MTRRdefType:
3105         env->mtrr_deftype = val;
3106         break;
3107     default:
3108         /* XXX: exception ? */
3109         break;
3110     }
3111 }
3112
3113 void helper_rdmsr(void)
3114 {
3115     uint64_t val;
3116
3117     helper_svm_check_intercept_param(SVM_EXIT_MSR, 0);
3118
3119     switch((uint32_t)ECX) {
3120     case MSR_IA32_SYSENTER_CS:
3121         val = env->sysenter_cs;
3122         break;
3123     case MSR_IA32_SYSENTER_ESP:
3124         val = env->sysenter_esp;
3125         break;
3126     case MSR_IA32_SYSENTER_EIP:
3127         val = env->sysenter_eip;
3128         break;
3129     case MSR_IA32_APICBASE:
3130         val = cpu_get_apic_base(env);
3131         break;
3132     case MSR_EFER:
3133         val = env->efer;
3134         break;
3135     case MSR_STAR:
3136         val = env->star;
3137         break;
3138     case MSR_PAT:
3139         val = env->pat;
3140         break;
3141     case MSR_VM_HSAVE_PA:
3142         val = env->vm_hsave;
3143         break;
3144     case MSR_IA32_PERF_STATUS:
3145         /* tsc_increment_by_tick */
3146         val = 1000ULL;
3147         /* CPU multiplier */
3148         val |= (((uint64_t)4ULL) << 40);
3149         break;
3150 #ifdef TARGET_X86_64
3151     case MSR_LSTAR:
3152         val = env->lstar;
3153         break;
3154     case MSR_CSTAR:
3155         val = env->cstar;
3156         break;
3157     case MSR_FMASK:
3158         val = env->fmask;
3159         break;
3160     case MSR_FSBASE:
3161         val = env->segs[R_FS].base;
3162         break;
3163     case MSR_GSBASE:
3164         val = env->segs[R_GS].base;
3165         break;
3166     case MSR_KERNELGSBASE:
3167         val = env->kernelgsbase;
3168         break;
3169 #endif
3170 #ifdef USE_KQEMU
3171     case MSR_QPI_COMMBASE:
3172         if (env->kqemu_enabled) {
3173             val = kqemu_comm_base;
3174         } else {
3175             val = 0;
3176         }
3177         break;
3178 #endif
3179     case MSR_MTRRphysBase(0):
3180     case MSR_MTRRphysBase(1):
3181     case MSR_MTRRphysBase(2):
3182     case MSR_MTRRphysBase(3):
3183     case MSR_MTRRphysBase(4):
3184     case MSR_MTRRphysBase(5):
3185     case MSR_MTRRphysBase(6):
3186     case MSR_MTRRphysBase(7):
3187         val = env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysBase(0)) / 2].base;
3188         break;
3189     case MSR_MTRRphysMask(0):
3190     case MSR_MTRRphysMask(1):
3191     case MSR_MTRRphysMask(2):
3192     case MSR_MTRRphysMask(3):
3193     case MSR_MTRRphysMask(4):
3194     case MSR_MTRRphysMask(5):
3195     case MSR_MTRRphysMask(6):
3196     case MSR_MTRRphysMask(7):
3197         val = env->mtrr_var[((uint32_t)ECX - MSR_MTRRphysMask(0)) / 2].mask;
3198         break;
3199     case MSR_MTRRfix64K_00000:
3200         val = env->mtrr_fixed[0];
3201         break;
3202     case MSR_MTRRfix16K_80000:
3203     case MSR_MTRRfix16K_A0000:
3204         val = env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix16K_80000 + 1];
3205         break;
3206     case MSR_MTRRfix4K_C0000:
3207     case MSR_MTRRfix4K_C8000:
3208     case MSR_MTRRfix4K_D0000:
3209     case MSR_MTRRfix4K_D8000:
3210     case MSR_MTRRfix4K_E0000:
3211     case MSR_MTRRfix4K_E8000:
3212     case MSR_MTRRfix4K_F0000:
3213     case MSR_MTRRfix4K_F8000:
3214         val = env->mtrr_fixed[(uint32_t)ECX - MSR_MTRRfix4K_C0000 + 3];
3215         break;
3216     case MSR_MTRRdefType:
3217         val = env->mtrr_deftype;
3218         break;
3219     case MSR_MTRRcap:
3220         if (env->cpuid_features & CPUID_MTRR)
3221             val = MSR_MTRRcap_VCNT | MSR_MTRRcap_FIXRANGE_SUPPORT | MSR_MTRRcap_WC_SUPPORTED;
3222         else
3223             /* XXX: exception ? */
3224             val = 0;
3225         break;
3226     default:
3227         /* XXX: exception ? */
3228         val = 0;
3229         break;
3230     }
3231     EAX = (uint32_t)(val);
3232     EDX = (uint32_t)(val >> 32);
3233 }
3234 #endif
3235
3236 target_ulong helper_lsl(target_ulong selector1)
3237 {
3238     unsigned int limit;
3239     uint32_t e1, e2, eflags, selector;
3240     int rpl, dpl, cpl, type;
3241
3242     selector = selector1 & 0xffff;
3243     eflags = helper_cc_compute_all(CC_OP);
3244     if (load_segment(&e1, &e2, selector) != 0)
3245         goto fail;
3246     rpl = selector & 3;
3247     dpl = (e2 >> DESC_DPL_SHIFT) & 3;
3248     cpl = env->hflags & HF_CPL_MASK;
3249     if (e2 & DESC_S_MASK) {
3250         if ((e2 & DESC_CS_MASK) && (e2 & DESC_C_MASK)) {
3251             /* conforming */
3252         } else {
3253             if (dpl < cpl || dpl < rpl)
3254                 goto fail;
3255         }
3256     } else {
3257         type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
3258         switch(type) {
3259         case 1:
3260         case 2:
3261         case 3:
3262         case 9:
3263         case 11:
3264             break;
3265         default:
3266             goto fail;
3267         }
3268         if (dpl < cpl || dpl < rpl) {
3269         fail:
3270             CC_SRC = eflags & ~CC_Z;
3271             return 0;
3272         }
3273     }
3274     limit = get_seg_limit(e1, e2);
3275     CC_SRC = eflags | CC_Z;
3276     return limit;
3277 }
3278
3279 target_ulong helper_lar(target_ulong selector1)
3280 {
3281     uint32_t e1, e2, eflags, selector;
3282     int rpl, dpl, cpl, type;
3283
3284     selector = selector1 & 0xffff;
3285     eflags = helper_cc_compute_all(CC_OP);
3286     if ((selector & 0xfffc) == 0)
3287         goto fail;
3288     if (load_segment(&e1, &e2, selector) != 0)
3289         goto fail;
3290     rpl = selector & 3;
3291     dpl = (e2 >> DESC_DPL_SHIFT) & 3;
3292     cpl = env->hflags & HF_CPL_MASK;
3293     if (e2 & DESC_S_MASK) {
3294         if ((e2 & DESC_CS_MASK) && (e2 & DESC_C_MASK)) {
3295             /* conforming */
3296         } else {
3297             if (dpl < cpl || dpl < rpl)
3298                 goto fail;
3299         }
3300     } else {
3301         type = (e2 >> DESC_TYPE_SHIFT) & 0xf;
3302         switch(type) {
3303         case 1:
3304         case 2:
3305         case 3:
3306         case 4:
3307         case 5:
3308         case 9:
3309         case 11:
3310         case 12:
3311             break;
3312         default:
3313             goto fail;
3314         }
3315         if (dpl < cpl || dpl < rpl) {
3316         fail:
3317             CC_SRC = eflags & ~CC_Z;
3318             return 0;
3319         }
3320     }
3321     CC_SRC = eflags | CC_Z;
3322     return e2 & 0x00f0ff00;
3323 }
3324
3325 void helper_verr(target_ulong selector1)
3326 {
3327     uint32_t e1, e2, eflags, selector;
3328     int rpl, dpl, cpl;
3329
3330     selector = selector1 & 0xffff;
3331     eflags = helper_cc_compute_all(CC_OP);
3332     if ((selector & 0xfffc) == 0)
3333         goto fail;
3334     if (load_segment(&e1, &e2, selector) != 0)
3335         goto fail;
3336     if (!(e2 & DESC_S_MASK))
3337         goto fail;
3338     rpl = selector & 3;
3339     dpl = (e2 >> DESC_DPL_SHIFT) & 3;
3340     cpl = env->hflags & HF_CPL_MASK;
3341     if (e2 & DESC_CS_MASK) {
3342         if (!(e2 & DESC_R_MASK))
3343             goto fail;
3344         if (!(e2 & DESC_C_MASK)) {
3345             if (dpl < cpl || dpl < rpl)
3346                 goto fail;
3347         }
3348     } else {
3349         if (dpl < cpl || dpl < rpl) {
3350         fail:
3351             CC_SRC = eflags & ~CC_Z;
3352             return;
3353         }
3354     }
3355     CC_SRC = eflags | CC_Z;
3356 }
3357
3358 void helper_verw(target_ulong selector1)
3359 {
3360     uint32_t e1, e2, eflags, selector;
3361     int rpl, dpl, cpl;
3362
3363     selector = selector1 & 0xffff;
3364     eflags = helper_cc_compute_all(CC_OP);
3365     if ((selector & 0xfffc) == 0)
3366         goto fail;
3367     if (load_segment(&e1, &e2, selector) != 0)
3368         goto fail;
3369     if (!(e2 & DESC_S_MASK))
3370         goto fail;
3371     rpl = selector & 3;
3372     dpl = (e2 >> DESC_DPL_SHIFT) & 3;
3373     cpl = env->hflags & HF_CPL_MASK;
3374     if (e2 & DESC_CS_MASK) {
3375         goto fail;
3376     } else {
3377         if (dpl < cpl || dpl < rpl)
3378             goto fail;
3379         if (!(e2 & DESC_W_MASK)) {
3380         fail:
3381             CC_SRC = eflags & ~CC_Z;
3382             return;
3383         }
3384     }
3385     CC_SRC = eflags | CC_Z;
3386 }
3387
3388 /* x87 FPU helpers */
3389
3390 static void fpu_set_exception(int mask)
3391 {
3392     env->fpus |= mask;
3393     if (env->fpus & (~env->fpuc & FPUC_EM))
3394         env->fpus |= FPUS_SE | FPUS_B;
3395 }
3396
3397 static inline CPU86_LDouble helper_fdiv(CPU86_LDouble a, CPU86_LDouble b)
3398 {
3399     if (b == 0.0)
3400         fpu_set_exception(FPUS_ZE);
3401     return a / b;
3402 }
3403
3404 static void fpu_raise_exception(void)
3405 {
3406     if (env->cr[0] & CR0_NE_MASK) {
3407         raise_exception(EXCP10_COPR);
3408     }
3409 #if !defined(CONFIG_USER_ONLY)
3410     else {
3411         cpu_set_ferr(env);
3412     }
3413 #endif
3414 }
3415
3416 void helper_flds_FT0(uint32_t val)
3417 {
3418     union {
3419         float32 f;
3420         uint32_t i;
3421     } u;
3422     u.i = val;
3423     FT0 = float32_to_floatx(u.f, &env->fp_status);
3424 }
3425
3426 void helper_fldl_FT0(uint64_t val)
3427 {
3428     union {
3429         float64 f;
3430         uint64_t i;
3431     } u;
3432     u.i = val;
3433     FT0 = float64_to_floatx(u.f, &env->fp_status);
3434 }
3435
3436 void helper_fildl_FT0(int32_t val)
3437 {
3438     FT0 = int32_to_floatx(val, &env->fp_status);
3439 }
3440
3441 void helper_flds_ST0(uint32_t val)
3442 {
3443     int new_fpstt;
3444     union {
3445         float32 f;
3446         uint32_t i;
3447     } u;
3448     new_fpstt = (env->fpstt - 1) & 7;
3449     u.i = val;
3450     env->fpregs[new_fpstt].d = float32_to_floatx(u.f, &env->fp_status);
3451     env->fpstt = new_fpstt;
3452     env->fptags[new_fpstt] = 0; /* validate stack entry */
3453 }
3454
3455 void helper_fldl_ST0(uint64_t val)
3456 {
3457     int new_fpstt;
3458     union {
3459         float64 f;
3460         uint64_t i;
3461     } u;
3462     new_fpstt = (env->fpstt - 1) & 7;
3463     u.i = val;
3464     env->fpregs[new_fpstt].d = float64_to_floatx(u.f, &env->fp_status);
3465     env->fpstt = new_fpstt;
3466     env->fptags[new_fpstt] = 0; /* validate stack entry */
3467 }
3468
3469 void helper_fildl_ST0(int32_t val)
3470 {
3471     int new_fpstt;
3472     new_fpstt = (env->fpstt - 1) & 7;
3473     env->fpregs[new_fpstt].d = int32_to_floatx(val, &env->fp_status);
3474     env->fpstt = new_fpstt;
3475     env->fptags[new_fpstt] = 0; /* validate stack entry */
3476 }
3477
3478 void helper_fildll_ST0(int64_t val)
3479 {
3480     int new_fpstt;
3481     new_fpstt = (env->fpstt - 1) & 7;
3482     env->fpregs[new_fpstt].d = int64_to_floatx(val, &env->fp_status);
3483     env->fpstt = new_fpstt;
3484     env->fptags[new_fpstt] = 0; /* validate stack entry */
3485 }
3486
3487 uint32_t helper_fsts_ST0(void)
3488 {
3489     union {
3490         float32 f;
3491         uint32_t i;
3492     } u;
3493     u.f = floatx_to_float32(ST0, &env->fp_status);
3494     return u.i;
3495 }
3496
3497 uint64_t helper_fstl_ST0(void)
3498 {
3499     union {
3500         float64 f;
3501         uint64_t i;
3502     } u;
3503     u.f = floatx_to_float64(ST0, &env->fp_status);
3504     return u.i;
3505 }
3506
3507 int32_t helper_fist_ST0(void)
3508 {
3509     int32_t val;
3510     val = floatx_to_int32(ST0, &env->fp_status);
3511     if (val != (int16_t)val)
3512         val = -32768;
3513     return val;
3514 }
3515
3516 int32_t helper_fistl_ST0(void)
3517 {
3518     int32_t val;
3519     val = floatx_to_int32(ST0, &env->fp_status);
3520     return val;
3521 }
3522
3523 int64_t helper_fistll_ST0(void)
3524 {
3525     int64_t val;
3526     val = floatx_to_int64(ST0, &env->fp_status);
3527     return val;
3528 }
3529
3530 int32_t helper_fistt_ST0(void)
3531 {
3532     int32_t val;
3533     val = floatx_to_int32_round_to_zero(ST0, &env->fp_status);
3534     if (val != (int16_t)val)
3535         val = -32768;
3536     return val;
3537 }
3538
3539 int32_t helper_fisttl_ST0(void)
3540 {
3541     int32_t val;
3542     val = floatx_to_int32_round_to_zero(ST0, &env->fp_status);
3543     return val;
3544 }
3545
3546 int64_t helper_fisttll_ST0(void)
3547 {
3548     int64_t val;
3549     val = floatx_to_int64_round_to_zero(ST0, &env->fp_status);
3550     return val;
3551 }
3552
3553 void helper_fldt_ST0(target_ulong ptr)
3554 {
3555     int new_fpstt;
3556     new_fpstt = (env->fpstt - 1) & 7;
3557     env->fpregs[new_fpstt].d = helper_fldt(ptr);
3558     env->fpstt = new_fpstt;
3559     env->fptags[new_fpstt] = 0; /* validate stack entry */
3560 }
3561
3562 void helper_fstt_ST0(target_ulong ptr)
3563 {
3564     helper_fstt(ST0, ptr);
3565 }
3566
3567 void helper_fpush(void)
3568 {
3569     fpush();
3570 }
3571
3572 void helper_fpop(void)
3573 {
3574     fpop();
3575 }
3576
3577 void helper_fdecstp(void)
3578 {
3579     env->fpstt = (env->fpstt - 1) & 7;
3580     env->fpus &= (~0x4700);
3581 }
3582
3583 void helper_fincstp(void)
3584 {
3585     env->fpstt = (env->fpstt + 1) & 7;
3586     env->fpus &= (~0x4700);
3587 }
3588
3589 /* FPU move */
3590
3591 void helper_ffree_STN(int st_index)
3592 {
3593     env->fptags[(env->fpstt + st_index) & 7] = 1;
3594 }
3595
3596 void helper_fmov_ST0_FT0(void)
3597 {
3598     ST0 = FT0;
3599 }
3600
3601 void helper_fmov_FT0_STN(int st_index)
3602 {
3603     FT0 = ST(st_index);
3604 }
3605
3606 void helper_fmov_ST0_STN(int st_index)
3607 {
3608     ST0 = ST(st_index);
3609 }
3610
3611 void helper_fmov_STN_ST0(int st_index)
3612 {
3613     ST(st_index) = ST0;
3614 }
3615
3616 void helper_fxchg_ST0_STN(int st_index)
3617 {
3618     CPU86_LDouble tmp;
3619     tmp = ST(st_index);
3620     ST(st_index) = ST0;
3621     ST0 = tmp;
3622 }
3623
3624 /* FPU operations */
3625
3626 static const int fcom_ccval[4] = {0x0100, 0x4000, 0x0000, 0x4500};
3627
3628 void helper_fcom_ST0_FT0(void)
3629 {
3630     int ret;
3631
3632     ret = floatx_compare(ST0, FT0, &env->fp_status);
3633     env->fpus = (env->fpus & ~0x4500) | fcom_ccval[ret + 1];
3634 }
3635
3636 void helper_fucom_ST0_FT0(void)
3637 {
3638     int ret;
3639
3640     ret = floatx_compare_quiet(ST0, FT0, &env->fp_status);
3641     env->fpus = (env->fpus & ~0x4500) | fcom_ccval[ret+ 1];
3642 }
3643
3644 static const int fcomi_ccval[4] = {CC_C, CC_Z, 0, CC_Z | CC_P | CC_C};
3645
3646 void helper_fcomi_ST0_FT0(void)
3647 {
3648     int eflags;
3649     int ret;
3650
3651     ret = floatx_compare(ST0, FT0, &env->fp_status);
3652     eflags = helper_cc_compute_all(CC_OP);
3653     eflags = (eflags & ~(CC_Z | CC_P | CC_C)) | fcomi_ccval[ret + 1];
3654     CC_SRC = eflags;
3655 }
3656
3657 void helper_fucomi_ST0_FT0(void)
3658 {
3659     int eflags;
3660     int ret;
3661
3662     ret = floatx_compare_quiet(ST0, FT0, &env->fp_status);
3663     eflags = helper_cc_compute_all(CC_OP);
3664     eflags = (eflags & ~(CC_Z | CC_P | CC_C)) | fcomi_ccval[ret + 1];
3665     CC_SRC = eflags;
3666 }
3667
3668 void helper_fadd_ST0_FT0(void)
3669 {
3670     ST0 += FT0;
3671 }
3672
3673 void helper_fmul_ST0_FT0(void)
3674 {
3675     ST0 *= FT0;
3676 }
3677
3678 void helper_fsub_ST0_FT0(void)
3679 {
3680     ST0 -= FT0;
3681 }
3682
3683 void helper_fsubr_ST0_FT0(void)
3684 {
3685     ST0 = FT0 - ST0;
3686 }
3687
3688 void helper_fdiv_ST0_FT0(void)
3689 {
3690     ST0 = helper_fdiv(ST0, FT0);
3691 }
3692
3693 void helper_fdivr_ST0_FT0(void)
3694 {
3695     ST0 = helper_fdiv(FT0, ST0);
3696 }
3697
3698 /* fp operations between STN and ST0 */
3699
3700 void helper_fadd_STN_ST0(int st_index)
3701 {
3702     ST(st_index) += ST0;
3703 }
3704
3705 void helper_fmul_STN_ST0(int st_index)
3706 {
3707     ST(st_index) *= ST0;
3708 }
3709
3710 void helper_fsub_STN_ST0(int st_index)
3711 {
3712     ST(st_index) -= ST0;
3713 }
3714
3715 void helper_fsubr_STN_ST0(int st_index)
3716 {
3717     CPU86_LDouble *p;
3718     p = &ST(st_index);
3719     *p = ST0 - *p;
3720 }
3721
3722 void helper_fdiv_STN_ST0(int st_index)
3723 {
3724     CPU86_LDouble *p;
3725     p = &ST(st_index);
3726     *p = helper_fdiv(*p, ST0);
3727 }
3728
3729 void helper_fdivr_STN_ST0(int st_index)
3730 {
3731     CPU86_LDouble *p;
3732     p = &ST(st_index);
3733     *p = helper_fdiv(ST0, *p);
3734 }
3735
3736 /* misc FPU operations */
3737 void helper_fchs_ST0(void)
3738 {
3739     ST0 = floatx_chs(ST0);
3740 }
3741
3742 void helper_fabs_ST0(void)
3743 {
3744     ST0 = floatx_abs(ST0);
3745 }
3746
3747 void helper_fld1_ST0(void)
3748 {
3749     ST0 = f15rk[1];
3750 }
3751
3752 void helper_fldl2t_ST0(void)
3753 {
3754     ST0 = f15rk[6];
3755 }
3756
3757 void helper_fldl2e_ST0(void)
3758 {
3759     ST0 = f15rk[5];
3760 }
3761
3762 void helper_fldpi_ST0(void)
3763 {
3764     ST0 = f15rk[2];
3765 }
3766
3767 void helper_fldlg2_ST0(void)
3768 {
3769     ST0 = f15rk[3];
3770 }
3771
3772 void helper_fldln2_ST0(void)
3773 {
3774     ST0 = f15rk[4];
3775 }
3776
3777 void helper_fldz_ST0(void)
3778 {
3779     ST0 = f15rk[0];
3780 }
3781
3782 void helper_fldz_FT0(void)
3783 {
3784     FT0 = f15rk[0];
3785 }
3786
3787 uint32_t helper_fnstsw(void)
3788 {
3789     return (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
3790 }
3791
3792 uint32_t helper_fnstcw(void)
3793 {
3794     return env->fpuc;
3795 }
3796
3797 static void update_fp_status(void)
3798 {
3799     int rnd_type;
3800
3801     /* set rounding mode */
3802     switch(env->fpuc & RC_MASK) {
3803     default:
3804     case RC_NEAR:
3805         rnd_type = float_round_nearest_even;
3806         break;
3807     case RC_DOWN:
3808         rnd_type = float_round_down;
3809         break;
3810     case RC_UP:
3811         rnd_type = float_round_up;
3812         break;
3813     case RC_CHOP:
3814         rnd_type = float_round_to_zero;
3815         break;
3816     }
3817     set_float_rounding_mode(rnd_type, &env->fp_status);
3818 #ifdef FLOATX80
3819     switch((env->fpuc >> 8) & 3) {
3820     case 0:
3821         rnd_type = 32;
3822         break;
3823     case 2:
3824         rnd_type = 64;
3825         break;
3826     case 3:
3827     default:
3828         rnd_type = 80;
3829         break;
3830     }
3831     set_floatx80_rounding_precision(rnd_type, &env->fp_status);
3832 #endif
3833 }
3834
3835 void helper_fldcw(uint32_t val)
3836 {
3837     env->fpuc = val;
3838     update_fp_status();
3839 }
3840
3841 void helper_fclex(void)
3842 {
3843     env->fpus &= 0x7f00;
3844 }
3845
3846 void helper_fwait(void)
3847 {
3848     if (env->fpus & FPUS_SE)
3849         fpu_raise_exception();
3850 }
3851
3852 void helper_fninit(void)
3853 {
3854     env->fpus = 0;
3855     env->fpstt = 0;
3856     env->fpuc = 0x37f;
3857     env->fptags[0] = 1;
3858     env->fptags[1] = 1;
3859     env->fptags[2] = 1;
3860     env->fptags[3] = 1;
3861     env->fptags[4] = 1;
3862     env->fptags[5] = 1;
3863     env->fptags[6] = 1;
3864     env->fptags[7] = 1;
3865 }
3866
3867 /* BCD ops */
3868
3869 void helper_fbld_ST0(target_ulong ptr)
3870 {
3871     CPU86_LDouble tmp;
3872     uint64_t val;
3873     unsigned int v;
3874     int i;
3875
3876     val = 0;
3877     for(i = 8; i >= 0; i--) {
3878         v = ldub(ptr + i);
3879         val = (val * 100) + ((v >> 4) * 10) + (v & 0xf);
3880     }
3881     tmp = val;
3882     if (ldub(ptr + 9) & 0x80)
3883         tmp = -tmp;
3884     fpush();
3885     ST0 = tmp;
3886 }
3887
3888 void helper_fbst_ST0(target_ulong ptr)
3889 {
3890     int v;
3891     target_ulong mem_ref, mem_end;
3892     int64_t val;
3893
3894     val = floatx_to_int64(ST0, &env->fp_status);
3895     mem_ref = ptr;
3896     mem_end = mem_ref + 9;
3897     if (val < 0) {
3898         stb(mem_end, 0x80);
3899         val = -val;
3900     } else {
3901         stb(mem_end, 0x00);
3902     }
3903     while (mem_ref < mem_end) {
3904         if (val == 0)
3905             break;
3906         v = val % 100;
3907         val = val / 100;
3908         v = ((v / 10) << 4) | (v % 10);
3909         stb(mem_ref++, v);
3910     }
3911     while (mem_ref < mem_end) {
3912         stb(mem_ref++, 0);
3913     }
3914 }
3915
3916 void helper_f2xm1(void)
3917 {
3918     ST0 = pow(2.0,ST0) - 1.0;
3919 }
3920
3921 void helper_fyl2x(void)
3922 {
3923     CPU86_LDouble fptemp;
3924
3925     fptemp = ST0;
3926     if (fptemp>0.0){
3927         fptemp = log(fptemp)/log(2.0);   /* log2(ST) */
3928         ST1 *= fptemp;
3929         fpop();
3930     } else {
3931         env->fpus &= (~0x4700);
3932         env->fpus |= 0x400;
3933     }
3934 }
3935
3936 void helper_fptan(void)
3937 {
3938     CPU86_LDouble fptemp;
3939
3940     fptemp = ST0;
3941     if((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
3942         env->fpus |= 0x400;
3943     } else {
3944         ST0 = tan(fptemp);
3945         fpush();
3946         ST0 = 1.0;
3947         env->fpus &= (~0x400);  /* C2 <-- 0 */
3948         /* the above code is for  |arg| < 2**52 only */
3949     }
3950 }
3951
3952 void helper_fpatan(void)
3953 {
3954     CPU86_LDouble fptemp, fpsrcop;
3955
3956     fpsrcop = ST1;
3957     fptemp = ST0;
3958     ST1 = atan2(fpsrcop,fptemp);
3959     fpop();
3960 }
3961
3962 void helper_fxtract(void)
3963 {
3964     CPU86_LDoubleU temp;
3965     unsigned int expdif;
3966
3967     temp.d = ST0;
3968     expdif = EXPD(temp) - EXPBIAS;
3969     /*DP exponent bias*/
3970     ST0 = expdif;
3971     fpush();
3972     BIASEXPONENT(temp);
3973     ST0 = temp.d;
3974 }
3975
3976 void helper_fprem1(void)
3977 {
3978     CPU86_LDouble dblq, fpsrcop, fptemp;
3979     CPU86_LDoubleU fpsrcop1, fptemp1;
3980     int expdif;
3981     signed long long int q;
3982
3983     if (isinf(ST0) || isnan(ST0) || isnan(ST1) || (ST1 == 0.0)) {
3984         ST0 = 0.0 / 0.0; /* NaN */
3985         env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
3986         return;
3987     }
3988
3989     fpsrcop = ST0;
3990     fptemp = ST1;
3991     fpsrcop1.d = fpsrcop;
3992     fptemp1.d = fptemp;
3993     expdif = EXPD(fpsrcop1) - EXPD(fptemp1);
3994
3995     if (expdif < 0) {
3996         /* optimisation? taken from the AMD docs */
3997         env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
3998         /* ST0 is unchanged */
3999         return;
4000     }
4001
4002     if (expdif < 53) {
4003         dblq = fpsrcop / fptemp;
4004         /* round dblq towards nearest integer */
4005         dblq = rint(dblq);
4006         ST0 = fpsrcop - fptemp * dblq;
4007
4008         /* convert dblq to q by truncating towards zero */
4009         if (dblq < 0.0)
4010            q = (signed long long int)(-dblq);
4011         else
4012            q = (signed long long int)dblq;
4013
4014         env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4015                                 /* (C0,C3,C1) <-- (q2,q1,q0) */
4016         env->fpus |= (q & 0x4) << (8 - 2);  /* (C0) <-- q2 */
4017         env->fpus |= (q & 0x2) << (14 - 1); /* (C3) <-- q1 */
4018         env->fpus |= (q & 0x1) << (9 - 0);  /* (C1) <-- q0 */
4019     } else {
4020         env->fpus |= 0x400;  /* C2 <-- 1 */
4021         fptemp = pow(2.0, expdif - 50);
4022         fpsrcop = (ST0 / ST1) / fptemp;
4023         /* fpsrcop = integer obtained by chopping */
4024         fpsrcop = (fpsrcop < 0.0) ?
4025                   -(floor(fabs(fpsrcop))) : floor(fpsrcop);
4026         ST0 -= (ST1 * fpsrcop * fptemp);
4027     }
4028 }
4029
4030 void helper_fprem(void)
4031 {
4032     CPU86_LDouble dblq, fpsrcop, fptemp;
4033     CPU86_LDoubleU fpsrcop1, fptemp1;
4034     int expdif;
4035     signed long long int q;
4036
4037     if (isinf(ST0) || isnan(ST0) || isnan(ST1) || (ST1 == 0.0)) {
4038        ST0 = 0.0 / 0.0; /* NaN */
4039        env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4040        return;
4041     }
4042
4043     fpsrcop = (CPU86_LDouble)ST0;
4044     fptemp = (CPU86_LDouble)ST1;
4045     fpsrcop1.d = fpsrcop;
4046     fptemp1.d = fptemp;
4047     expdif = EXPD(fpsrcop1) - EXPD(fptemp1);
4048
4049     if (expdif < 0) {
4050         /* optimisation? taken from the AMD docs */
4051         env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4052         /* ST0 is unchanged */
4053         return;
4054     }
4055
4056     if ( expdif < 53 ) {
4057         dblq = fpsrcop/*ST0*/ / fptemp/*ST1*/;
4058         /* round dblq towards zero */
4059         dblq = (dblq < 0.0) ? ceil(dblq) : floor(dblq);
4060         ST0 = fpsrcop/*ST0*/ - fptemp * dblq;
4061
4062         /* convert dblq to q by truncating towards zero */
4063         if (dblq < 0.0)
4064            q = (signed long long int)(-dblq);
4065         else
4066            q = (signed long long int)dblq;
4067
4068         env->fpus &= (~0x4700); /* (C3,C2,C1,C0) <-- 0000 */
4069                                 /* (C0,C3,C1) <-- (q2,q1,q0) */
4070         env->fpus |= (q & 0x4) << (8 - 2);  /* (C0) <-- q2 */
4071         env->fpus |= (q & 0x2) << (14 - 1); /* (C3) <-- q1 */
4072         env->fpus |= (q & 0x1) << (9 - 0);  /* (C1) <-- q0 */
4073     } else {
4074         int N = 32 + (expdif % 32); /* as per AMD docs */
4075         env->fpus |= 0x400;  /* C2 <-- 1 */
4076         fptemp = pow(2.0, (double)(expdif - N));
4077         fpsrcop = (ST0 / ST1) / fptemp;
4078         /* fpsrcop = integer obtained by chopping */
4079         fpsrcop = (fpsrcop < 0.0) ?
4080                   -(floor(fabs(fpsrcop))) : floor(fpsrcop);
4081         ST0 -= (ST1 * fpsrcop * fptemp);
4082     }
4083 }
4084
4085 void helper_fyl2xp1(void)
4086 {
4087     CPU86_LDouble fptemp;
4088
4089     fptemp = ST0;
4090     if ((fptemp+1.0)>0.0) {
4091         fptemp = log(fptemp+1.0) / log(2.0); /* log2(ST+1.0) */
4092         ST1 *= fptemp;
4093         fpop();
4094     } else {
4095         env->fpus &= (~0x4700);
4096         env->fpus |= 0x400;
4097     }
4098 }
4099
4100 void helper_fsqrt(void)
4101 {
4102     CPU86_LDouble fptemp;
4103
4104     fptemp = ST0;
4105     if (fptemp<0.0) {
4106         env->fpus &= (~0x4700);  /* (C3,C2,C1,C0) <-- 0000 */
4107         env->fpus |= 0x400;
4108     }
4109     ST0 = sqrt(fptemp);
4110 }
4111
4112 void helper_fsincos(void)
4113 {
4114     CPU86_LDouble fptemp;
4115
4116     fptemp = ST0;
4117     if ((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
4118         env->fpus |= 0x400;
4119     } else {
4120         ST0 = sin(fptemp);
4121         fpush();
4122         ST0 = cos(fptemp);
4123         env->fpus &= (~0x400);  /* C2 <-- 0 */
4124         /* the above code is for  |arg| < 2**63 only */
4125     }
4126 }
4127
4128 void helper_frndint(void)
4129 {
4130     ST0 = floatx_round_to_int(ST0, &env->fp_status);
4131 }
4132
4133 void helper_fscale(void)
4134 {
4135     ST0 = ldexp (ST0, (int)(ST1));
4136 }
4137
4138 void helper_fsin(void)
4139 {
4140     CPU86_LDouble fptemp;
4141
4142     fptemp = ST0;
4143     if ((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
4144         env->fpus |= 0x400;
4145     } else {
4146         ST0 = sin(fptemp);
4147         env->fpus &= (~0x400);  /* C2 <-- 0 */
4148         /* the above code is for  |arg| < 2**53 only */
4149     }
4150 }
4151
4152 void helper_fcos(void)
4153 {
4154     CPU86_LDouble fptemp;
4155
4156     fptemp = ST0;
4157     if((fptemp > MAXTAN)||(fptemp < -MAXTAN)) {
4158         env->fpus |= 0x400;
4159     } else {
4160         ST0 = cos(fptemp);
4161         env->fpus &= (~0x400);  /* C2 <-- 0 */
4162         /* the above code is for  |arg5 < 2**63 only */
4163     }
4164 }
4165
4166 void helper_fxam_ST0(void)
4167 {
4168     CPU86_LDoubleU temp;
4169     int expdif;
4170
4171     temp.d = ST0;
4172
4173     env->fpus &= (~0x4700);  /* (C3,C2,C1,C0) <-- 0000 */
4174     if (SIGND(temp))
4175         env->fpus |= 0x200; /* C1 <-- 1 */
4176
4177     /* XXX: test fptags too */
4178     expdif = EXPD(temp);
4179     if (expdif == MAXEXPD) {
4180 #ifdef USE_X86LDOUBLE
4181         if (MANTD(temp) == 0x8000000000000000ULL)
4182 #else
4183         if (MANTD(temp) == 0)
4184 #endif
4185             env->fpus |=  0x500 /*Infinity*/;
4186         else
4187             env->fpus |=  0x100 /*NaN*/;
4188     } else if (expdif == 0) {
4189         if (MANTD(temp) == 0)
4190             env->fpus |=  0x4000 /*Zero*/;
4191         else
4192             env->fpus |= 0x4400 /*Denormal*/;
4193     } else {
4194         env->fpus |= 0x400;
4195     }
4196 }
4197
4198 void helper_fstenv(target_ulong ptr, int data32)
4199 {
4200     int fpus, fptag, exp, i;
4201     uint64_t mant;
4202     CPU86_LDoubleU tmp;
4203
4204     fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
4205     fptag = 0;
4206     for (i=7; i>=0; i--) {
4207         fptag <<= 2;
4208         if (env->fptags[i]) {
4209             fptag |= 3;
4210         } else {
4211             tmp.d = env->fpregs[i].d;
4212             exp = EXPD(tmp);
4213             mant = MANTD(tmp);
4214             if (exp == 0 && mant == 0) {
4215                 /* zero */
4216                 fptag |= 1;
4217             } else if (exp == 0 || exp == MAXEXPD
4218 #ifdef USE_X86LDOUBLE
4219                        || (mant & (1LL << 63)) == 0
4220 #endif
4221                        ) {
4222                 /* NaNs, infinity, denormal */
4223                 fptag |= 2;
4224             }
4225         }
4226     }
4227     if (data32) {
4228         /* 32 bit */
4229         stl(ptr, env->fpuc);
4230         stl(ptr + 4, fpus);
4231         stl(ptr + 8, fptag);
4232         stl(ptr + 12, 0); /* fpip */
4233         stl(ptr + 16, 0); /* fpcs */
4234         stl(ptr + 20, 0); /* fpoo */
4235         stl(ptr + 24, 0); /* fpos */
4236     } else {
4237         /* 16 bit */
4238         stw(ptr, env->fpuc);
4239         stw(ptr + 2, fpus);
4240         stw(ptr + 4, fptag);
4241         stw(ptr + 6, 0);
4242         stw(ptr + 8, 0);
4243         stw(ptr + 10, 0);
4244         stw(ptr + 12, 0);
4245     }
4246 }
4247
4248 void helper_fldenv(target_ulong ptr, int data32)
4249 {
4250     int i, fpus, fptag;
4251
4252     if (data32) {
4253         env->fpuc = lduw(ptr);
4254         fpus = lduw(ptr + 4);
4255         fptag = lduw(ptr + 8);
4256     }
4257     else {
4258         env->fpuc = lduw(ptr);
4259         fpus = lduw(ptr + 2);
4260         fptag = lduw(ptr + 4);
4261     }
4262     env->fpstt = (fpus >> 11) & 7;
4263     env->fpus = fpus & ~0x3800;
4264     for(i = 0;i < 8; i++) {
4265         env->fptags[i] = ((fptag & 3) == 3);
4266         fptag >>= 2;
4267     }
4268 }
4269
4270 void helper_fsave(target_ulong ptr, int data32)
4271 {
4272     CPU86_LDouble tmp;
4273     int i;
4274
4275     helper_fstenv(ptr, data32);
4276
4277     ptr += (14 << data32);
4278     for(i = 0;i < 8; i++) {
4279         tmp = ST(i);
4280         helper_fstt(tmp, ptr);
4281         ptr += 10;
4282     }
4283
4284     /* fninit */
4285     env->fpus = 0;
4286     env->fpstt = 0;
4287     env->fpuc = 0x37f;
4288     env->fptags[0] = 1;
4289     env->fptags[1] = 1;
4290     env->fptags[2] = 1;
4291     env->fptags[3] = 1;
4292     env->fptags[4] = 1;
4293     env->fptags[5] = 1;
4294     env->fptags[6] = 1;
4295     env->fptags[7] = 1;
4296 }
4297
4298 void helper_frstor(target_ulong ptr, int data32)
4299 {
4300     CPU86_LDouble tmp;
4301     int i;
4302
4303     helper_fldenv(ptr, data32);
4304     ptr += (14 << data32);
4305
4306     for(i = 0;i < 8; i++) {
4307         tmp = helper_fldt(ptr);
4308         ST(i) = tmp;
4309         ptr += 10;
4310     }
4311 }
4312
4313 void helper_fxsave(target_ulong ptr, int data64)
4314 {
4315     int fpus, fptag, i, nb_xmm_regs;
4316     CPU86_LDouble tmp;
4317     target_ulong addr;
4318
4319     fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
4320     fptag = 0;
4321     for(i = 0; i < 8; i++) {
4322         fptag |= (env->fptags[i] << i);
4323     }
4324     stw(ptr, env->fpuc);
4325     stw(ptr + 2, fpus);
4326     stw(ptr + 4, fptag ^ 0xff);
4327 #ifdef TARGET_X86_64
4328     if (data64) {
4329         stq(ptr + 0x08, 0); /* rip */
4330         stq(ptr + 0x10, 0); /* rdp */
4331     } else
4332 #endif
4333     {
4334         stl(ptr + 0x08, 0); /* eip */
4335         stl(ptr + 0x0c, 0); /* sel  */
4336         stl(ptr + 0x10, 0); /* dp */
4337         stl(ptr + 0x14, 0); /* sel  */
4338     }
4339
4340     addr = ptr + 0x20;
4341     for(i = 0;i < 8; i++) {
4342         tmp = ST(i);
4343         helper_fstt(tmp, addr);
4344         addr += 16;
4345     }
4346
4347     if (env->cr[4] & CR4_OSFXSR_MASK) {
4348         /* XXX: finish it */
4349         stl(ptr + 0x18, env->mxcsr); /* mxcsr */
4350         stl(ptr + 0x1c, 0x0000ffff); /* mxcsr_mask */
4351         if (env->hflags & HF_CS64_MASK)
4352             nb_xmm_regs = 16;
4353         else
4354             nb_xmm_regs = 8;
4355         addr = ptr + 0xa0;
4356         /* Fast FXSAVE leaves out the XMM registers */
4357         if (!(env->efer & MSR_EFER_FFXSR)
4358           || (env->hflags & HF_CPL_MASK)
4359           || !(env->hflags & HF_LMA_MASK)) {
4360             for(i = 0; i < nb_xmm_regs; i++) {
4361                 stq(addr, env->xmm_regs[i].XMM_Q(0));
4362                 stq(addr + 8, env->xmm_regs[i].XMM_Q(1));
4363                 addr += 16;
4364             }
4365         }
4366     }
4367 }
4368
4369 void helper_fxrstor(target_ulong ptr, int data64)
4370 {
4371     int i, fpus, fptag, nb_xmm_regs;
4372     CPU86_LDouble tmp;
4373     target_ulong addr;
4374
4375     env->fpuc = lduw(ptr);
4376     fpus = lduw(ptr + 2);
4377     fptag = lduw(ptr + 4);
4378     env->fpstt = (fpus >> 11) & 7;
4379     env->fpus = fpus & ~0x3800;
4380     fptag ^= 0xff;
4381     for(i = 0;i < 8; i++) {
4382         env->fptags[i] = ((fptag >> i) & 1);
4383     }
4384
4385     addr = ptr + 0x20;
4386     for(i = 0;i < 8; i++) {
4387         tmp = helper_fldt(addr);
4388         ST(i) = tmp;
4389         addr += 16;
4390     }
4391
4392     if (env->cr[4] & CR4_OSFXSR_MASK) {
4393         /* XXX: finish it */
4394         env->mxcsr = ldl(ptr + 0x18);
4395         //ldl(ptr + 0x1c);
4396         if (env->hflags & HF_CS64_MASK)
4397             nb_xmm_regs = 16;
4398         else
4399             nb_xmm_regs = 8;
4400         addr = ptr + 0xa0;
4401         /* Fast FXRESTORE leaves out the XMM registers */
4402         if (!(env->efer & MSR_EFER_FFXSR)
4403           || (env->hflags & HF_CPL_MASK)
4404           || !(env->hflags & HF_LMA_MASK)) {
4405             for(i = 0; i < nb_xmm_regs; i++) {
4406                 env->xmm_regs[i].XMM_Q(0) = ldq(addr);
4407                 env->xmm_regs[i].XMM_Q(1) = ldq(addr + 8);
4408                 addr += 16;
4409             }
4410         }
4411     }
4412 }
4413
4414 #ifndef USE_X86LDOUBLE
4415
4416 void cpu_get_fp80(uint64_t *pmant, uint16_t *pexp, CPU86_LDouble f)
4417 {
4418     CPU86_LDoubleU temp;
4419     int e;
4420
4421     temp.d = f;
4422     /* mantissa */
4423     *pmant = (MANTD(temp) << 11) | (1LL << 63);
4424     /* exponent + sign */
4425     e = EXPD(temp) - EXPBIAS + 16383;
4426     e |= SIGND(temp) >> 16;
4427     *pexp = e;
4428 }
4429
4430 CPU86_LDouble cpu_set_fp80(uint64_t mant, uint16_t upper)
4431 {
4432     CPU86_LDoubleU temp;
4433     int e;
4434     uint64_t ll;
4435
4436     /* XXX: handle overflow ? */
4437     e = (upper & 0x7fff) - 16383 + EXPBIAS; /* exponent */
4438     e |= (upper >> 4) & 0x800; /* sign */
4439     ll = (mant >> 11) & ((1LL << 52) - 1);
4440 #ifdef __arm__
4441     temp.l.upper = (e << 20) | (ll >> 32);
4442     temp.l.lower = ll;
4443 #else
4444     temp.ll = ll | ((uint64_t)e << 52);
4445 #endif
4446     return temp.d;
4447 }
4448
4449 #else
4450
4451 void cpu_get_fp80(uint64_t *pmant, uint16_t *pexp, CPU86_LDouble f)
4452 {
4453     CPU86_LDoubleU temp;
4454
4455     temp.d = f;
4456     *pmant = temp.l.lower;
4457     *pexp = temp.l.upper;
4458 }
4459
4460 CPU86_LDouble cpu_set_fp80(uint64_t mant, uint16_t upper)
4461 {
4462     CPU86_LDoubleU temp;
4463
4464     temp.l.upper = upper;
4465     temp.l.lower = mant;
4466     return temp.d;
4467 }
4468 #endif
4469
4470 #ifdef TARGET_X86_64
4471
4472 //#define DEBUG_MULDIV
4473
4474 static void add128(uint64_t *plow, uint64_t *phigh, uint64_t a, uint64_t b)
4475 {
4476     *plow += a;
4477     /* carry test */
4478     if (*plow < a)
4479         (*phigh)++;
4480     *phigh += b;
4481 }
4482
4483 static void neg128(uint64_t *plow, uint64_t *phigh)
4484 {
4485     *plow = ~ *plow;
4486     *phigh = ~ *phigh;
4487     add128(plow, phigh, 1, 0);
4488 }
4489
4490 /* return TRUE if overflow */
4491 static int div64(uint64_t *plow, uint64_t *phigh, uint64_t b)
4492 {
4493     uint64_t q, r, a1, a0;
4494     int i, qb, ab;
4495
4496     a0 = *plow;
4497     a1 = *phigh;
4498     if (a1 == 0) {
4499         q = a0 / b;
4500         r = a0 % b;
4501         *plow = q;
4502         *phigh = r;
4503     } else {
4504         if (a1 >= b)
4505             return 1;
4506         /* XXX: use a better algorithm */
4507         for(i = 0; i < 64; i++) {
4508             ab = a1 >> 63;
4509             a1 = (a1 << 1) | (a0 >> 63);
4510             if (ab || a1 >= b) {
4511                 a1 -= b;
4512                 qb = 1;
4513             } else {
4514                 qb = 0;
4515             }
4516             a0 = (a0 << 1) | qb;
4517         }
4518 #if defined(DEBUG_MULDIV)
4519         printf("div: 0x%016" PRIx64 "%016" PRIx64 " / 0x%016" PRIx64 ": q=0x%016" PRIx64 " r=0x%016" PRIx64 "\n",
4520                *phigh, *plow, b, a0, a1);
4521 #endif
4522         *plow = a0;
4523         *phigh = a1;
4524     }
4525     return 0;
4526 }
4527
4528 /* return TRUE if overflow */
4529 static int idiv64(uint64_t *plow, uint64_t *phigh, int64_t b)
4530 {
4531     int sa, sb;
4532     sa = ((int64_t)*phigh < 0);
4533     if (sa)
4534         neg128(plow, phigh);
4535     sb = (b < 0);
4536     if (sb)
4537         b = -b;
4538     if (div64(plow, phigh, b) != 0)
4539         return 1;
4540     if (sa ^ sb) {
4541         if (*plow > (1ULL << 63))
4542             return 1;
4543         *plow = - *plow;
4544     } else {
4545         if (*plow >= (1ULL << 63))
4546             return 1;
4547     }
4548     if (sa)
4549         *phigh = - *phigh;
4550     return 0;
4551 }
4552
4553 void helper_mulq_EAX_T0(target_ulong t0)
4554 {
4555     uint64_t r0, r1;
4556
4557     mulu64(&r0, &r1, EAX, t0);
4558     EAX = r0;
4559     EDX = r1;
4560     CC_DST = r0;
4561     CC_SRC = r1;
4562 }
4563
4564 void helper_imulq_EAX_T0(target_ulong t0)
4565 {
4566     uint64_t r0, r1;
4567
4568     muls64(&r0, &r1, EAX, t0);
4569     EAX = r0;
4570     EDX = r1;
4571     CC_DST = r0;
4572     CC_SRC = ((int64_t)r1 != ((int64_t)r0 >> 63));
4573 }
4574
4575 target_ulong helper_imulq_T0_T1(target_ulong t0, target_ulong t1)
4576 {
4577     uint64_t r0, r1;
4578
4579     muls64(&r0, &r1, t0, t1);
4580     CC_DST = r0;
4581     CC_SRC = ((int64_t)r1 != ((int64_t)r0 >> 63));
4582     return r0;
4583 }
4584
4585 void helper_divq_EAX(target_ulong t0)
4586 {
4587     uint64_t r0, r1;
4588     if (t0 == 0) {
4589         raise_exception(EXCP00_DIVZ);
4590     }
4591     r0 = EAX;
4592     r1 = EDX;
4593     if (div64(&r0, &r1, t0))
4594         raise_exception(EXCP00_DIVZ);
4595     EAX = r0;
4596     EDX = r1;
4597 }
4598
4599 void helper_idivq_EAX(target_ulong t0)
4600 {
4601     uint64_t r0, r1;
4602     if (t0 == 0) {
4603         raise_exception(EXCP00_DIVZ);
4604     }
4605     r0 = EAX;
4606     r1 = EDX;
4607     if (idiv64(&r0, &r1, t0))
4608         raise_exception(EXCP00_DIVZ);
4609     EAX = r0;
4610     EDX = r1;
4611 }
4612 #endif
4613
4614 static void do_hlt(void)
4615 {
4616     env->hflags &= ~HF_INHIBIT_IRQ_MASK; /* needed if sti is just before */
4617     env->halted = 1;
4618     env->exception_index = EXCP_HLT;
4619     cpu_loop_exit();
4620 }
4621
4622 void helper_hlt(int next_eip_addend)
4623 {
4624     helper_svm_check_intercept_param(SVM_EXIT_HLT, 0);
4625     EIP += next_eip_addend;
4626
4627     do_hlt();
4628 }
4629
4630 void helper_monitor(target_ulong ptr)
4631 {
4632     if ((uint32_t)ECX != 0)
4633         raise_exception(EXCP0D_GPF);
4634     /* XXX: store address ? */
4635     helper_svm_check_intercept_param(SVM_EXIT_MONITOR, 0);
4636 }
4637
4638 void helper_mwait(int next_eip_addend)
4639 {
4640     if ((uint32_t)ECX != 0)
4641         raise_exception(EXCP0D_GPF);
4642     helper_svm_check_intercept_param(SVM_EXIT_MWAIT, 0);
4643     EIP += next_eip_addend;
4644
4645     /* XXX: not complete but not completely erroneous */
4646     if (env->cpu_index != 0 || env->next_cpu != NULL) {
4647         /* more than one CPU: do not sleep because another CPU may
4648            wake this one */
4649     } else {
4650         do_hlt();
4651     }
4652 }
4653
4654 void helper_debug(void)
4655 {
4656     env->exception_index = EXCP_DEBUG;
4657     cpu_loop_exit();
4658 }
4659
4660 void helper_raise_interrupt(int intno, int next_eip_addend)
4661 {
4662     raise_interrupt(intno, 1, 0, next_eip_addend);
4663 }
4664
4665 void helper_raise_exception(int exception_index)
4666 {
4667     raise_exception(exception_index);
4668 }
4669
4670 void helper_cli(void)
4671 {
4672     env->eflags &= ~IF_MASK;
4673 }
4674
4675 void helper_sti(void)
4676 {
4677     env->eflags |= IF_MASK;
4678 }
4679
4680 #if 0
4681 /* vm86plus instructions */
4682 void helper_cli_vm(void)
4683 {
4684     env->eflags &= ~VIF_MASK;
4685 }
4686
4687 void helper_sti_vm(void)
4688 {
4689     env->eflags |= VIF_MASK;
4690     if (env->eflags & VIP_MASK) {
4691         raise_exception(EXCP0D_GPF);
4692     }
4693 }
4694 #endif
4695
4696 void helper_set_inhibit_irq(void)
4697 {
4698     env->hflags |= HF_INHIBIT_IRQ_MASK;
4699 }
4700
4701 void helper_reset_inhibit_irq(void)
4702 {
4703     env->hflags &= ~HF_INHIBIT_IRQ_MASK;
4704 }
4705
4706 void helper_boundw(target_ulong a0, int v)
4707 {
4708     int low, high;
4709     low = ldsw(a0);
4710     high = ldsw(a0 + 2);
4711     v = (int16_t)v;
4712     if (v < low || v > high) {
4713         raise_exception(EXCP05_BOUND);
4714     }
4715 }
4716
4717 void helper_boundl(target_ulong a0, int v)
4718 {
4719     int low, high;
4720     low = ldl(a0);
4721     high = ldl(a0 + 4);
4722     if (v < low || v > high) {
4723         raise_exception(EXCP05_BOUND);
4724     }
4725 }
4726
4727 static float approx_rsqrt(float a)
4728 {
4729     return 1.0 / sqrt(a);
4730 }
4731
4732 static float approx_rcp(float a)
4733 {
4734     return 1.0 / a;
4735 }
4736
4737 #if !defined(CONFIG_USER_ONLY)
4738
4739 #define MMUSUFFIX _mmu
4740
4741 #define SHIFT 0
4742 #include "softmmu_template.h"
4743
4744 #define SHIFT 1
4745 #include "softmmu_template.h"
4746
4747 #define SHIFT 2
4748 #include "softmmu_template.h"
4749
4750 #define SHIFT 3
4751 #include "softmmu_template.h"
4752
4753 #endif
4754
4755 #if !defined(CONFIG_USER_ONLY)
4756 /* try to fill the TLB and return an exception if error. If retaddr is
4757    NULL, it means that the function was called in C code (i.e. not
4758    from generated code or from helper.c) */
4759 /* XXX: fix it to restore all registers */
4760 void tlb_fill(target_ulong addr, int is_write, int mmu_idx, void *retaddr)
4761 {
4762     TranslationBlock *tb;
4763     int ret;
4764     unsigned long pc;
4765     CPUX86State *saved_env;
4766
4767     /* XXX: hack to restore env in all cases, even if not called from
4768        generated code */
4769     saved_env = env;
4770     env = cpu_single_env;
4771
4772     ret = cpu_x86_handle_mmu_fault(env, addr, is_write, mmu_idx, 1);
4773     if (ret) {
4774         if (retaddr) {
4775             /* now we have a real cpu fault */
4776             pc = (unsigned long)retaddr;
4777             tb = tb_find_pc(pc);
4778             if (tb) {
4779                 /* the PC is inside the translated code. It means that we have
4780                    a virtual CPU fault */
4781                 cpu_restore_state(tb, env, pc, NULL);
4782             }
4783         }
4784         raise_exception_err(env->exception_index, env->error_code);
4785     }
4786     env = saved_env;
4787 }
4788 #endif
4789
4790 /* Secure Virtual Machine helpers */
4791
4792 #if defined(CONFIG_USER_ONLY)
4793
4794 void helper_vmrun(int aflag, int next_eip_addend)
4795 {
4796 }
4797 void helper_vmmcall(void)
4798 {
4799 }
4800 void helper_vmload(int aflag)
4801 {
4802 }
4803 void helper_vmsave(int aflag)
4804 {
4805 }
4806 void helper_stgi(void)
4807 {
4808 }
4809 void helper_clgi(void)
4810 {
4811 }
4812 void helper_skinit(void)
4813 {
4814 }
4815 void helper_invlpga(int aflag)
4816 {
4817 }
4818 void helper_vmexit(uint32_t exit_code, uint64_t exit_info_1)
4819 {
4820 }
4821 void helper_svm_check_intercept_param(uint32_t type, uint64_t param)
4822 {
4823 }
4824
4825 void helper_svm_check_io(uint32_t port, uint32_t param,
4826                          uint32_t next_eip_addend)
4827 {
4828 }
4829 #else
4830
4831 static inline void svm_save_seg(target_phys_addr_t addr,
4832                                 const SegmentCache *sc)
4833 {
4834     stw_phys(addr + offsetof(struct vmcb_seg, selector),
4835              sc->selector);
4836     stq_phys(addr + offsetof(struct vmcb_seg, base),
4837              sc->base);
4838     stl_phys(addr + offsetof(struct vmcb_seg, limit),
4839              sc->limit);
4840     stw_phys(addr + offsetof(struct vmcb_seg, attrib),
4841              ((sc->flags >> 8) & 0xff) | ((sc->flags >> 12) & 0x0f00));
4842 }
4843
4844 static inline void svm_load_seg(target_phys_addr_t addr, SegmentCache *sc)
4845 {
4846     unsigned int flags;
4847
4848     sc->selector = lduw_phys(addr + offsetof(struct vmcb_seg, selector));
4849     sc->base = ldq_phys(addr + offsetof(struct vmcb_seg, base));
4850     sc->limit = ldl_phys(addr + offsetof(struct vmcb_seg, limit));
4851     flags = lduw_phys(addr + offsetof(struct vmcb_seg, attrib));
4852     sc->flags = ((flags & 0xff) << 8) | ((flags & 0x0f00) << 12);
4853 }
4854
4855 static inline void svm_load_seg_cache(target_phys_addr_t addr,
4856                                       CPUState *env, int seg_reg)
4857 {
4858     SegmentCache sc1, *sc = &sc1;
4859     svm_load_seg(addr, sc);
4860     cpu_x86_load_seg_cache(env, seg_reg, sc->selector,
4861                            sc->base, sc->limit, sc->flags);
4862 }
4863
4864 void helper_vmrun(int aflag, int next_eip_addend)
4865 {
4866     target_ulong addr;
4867     uint32_t event_inj;
4868     uint32_t int_ctl;
4869
4870     helper_svm_check_intercept_param(SVM_EXIT_VMRUN, 0);
4871
4872     if (aflag == 2)
4873         addr = EAX;
4874     else
4875         addr = (uint32_t)EAX;
4876
4877     qemu_log_mask(CPU_LOG_TB_IN_ASM, "vmrun! " TARGET_FMT_lx "\n", addr);
4878
4879     env->vm_vmcb = addr;
4880
4881     /* save the current CPU state in the hsave page */
4882     stq_phys(env->vm_hsave + offsetof(struct vmcb, save.gdtr.base), env->gdt.base);
4883     stl_phys(env->vm_hsave + offsetof(struct vmcb, save.gdtr.limit), env->gdt.limit);
4884
4885     stq_phys(env->vm_hsave + offsetof(struct vmcb, save.idtr.base), env->idt.base);
4886     stl_phys(env->vm_hsave + offsetof(struct vmcb, save.idtr.limit), env->idt.limit);
4887
4888     stq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr0), env->cr[0]);
4889     stq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr2), env->cr[2]);
4890     stq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr3), env->cr[3]);
4891     stq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr4), env->cr[4]);
4892     stq_phys(env->vm_hsave + offsetof(struct vmcb, save.dr6), env->dr[6]);
4893     stq_phys(env->vm_hsave + offsetof(struct vmcb, save.dr7), env->dr[7]);
4894
4895     stq_phys(env->vm_hsave + offsetof(struct vmcb, save.efer), env->efer);
4896     stq_phys(env->vm_hsave + offsetof(struct vmcb, save.rflags), compute_eflags());
4897
4898     svm_save_seg(env->vm_hsave + offsetof(struct vmcb, save.es),
4899                   &env->segs[R_ES]);
4900     svm_save_seg(env->vm_hsave + offsetof(struct vmcb, save.cs),
4901                  &env->segs[R_CS]);
4902     svm_save_seg(env->vm_hsave + offsetof(struct vmcb, save.ss),
4903                  &env->segs[R_SS]);
4904     svm_save_seg(env->vm_hsave + offsetof(struct vmcb, save.ds),
4905                  &env->segs[R_DS]);
4906
4907     stq_phys(env->vm_hsave + offsetof(struct vmcb, save.rip),
4908              EIP + next_eip_addend);
4909     stq_phys(env->vm_hsave + offsetof(struct vmcb, save.rsp), ESP);
4910     stq_phys(env->vm_hsave + offsetof(struct vmcb, save.rax), EAX);
4911
4912     /* load the interception bitmaps so we do not need to access the
4913        vmcb in svm mode */
4914     env->intercept            = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept));
4915     env->intercept_cr_read    = lduw_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept_cr_read));
4916     env->intercept_cr_write   = lduw_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept_cr_write));
4917     env->intercept_dr_read    = lduw_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept_dr_read));
4918     env->intercept_dr_write   = lduw_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept_dr_write));
4919     env->intercept_exceptions = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.intercept_exceptions));
4920
4921     /* enable intercepts */
4922     env->hflags |= HF_SVMI_MASK;
4923
4924     env->tsc_offset = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, control.tsc_offset));
4925
4926     env->gdt.base  = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.gdtr.base));
4927     env->gdt.limit = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, save.gdtr.limit));
4928
4929     env->idt.base  = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.idtr.base));
4930     env->idt.limit = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, save.idtr.limit));
4931
4932     /* clear exit_info_2 so we behave like the real hardware */
4933     stq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_info_2), 0);
4934
4935     cpu_x86_update_cr0(env, ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr0)));
4936     cpu_x86_update_cr4(env, ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr4)));
4937     cpu_x86_update_cr3(env, ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr3)));
4938     env->cr[2] = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr2));
4939     int_ctl = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_ctl));
4940     env->hflags2 &= ~(HF2_HIF_MASK | HF2_VINTR_MASK);
4941     if (int_ctl & V_INTR_MASKING_MASK) {
4942         env->v_tpr = int_ctl & V_TPR_MASK;
4943         env->hflags2 |= HF2_VINTR_MASK;
4944         if (env->eflags & IF_MASK)
4945             env->hflags2 |= HF2_HIF_MASK;
4946     }
4947
4948     cpu_load_efer(env,
4949                   ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.efer)));
4950     env->eflags = 0;
4951     load_eflags(ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rflags)),
4952                 ~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
4953     CC_OP = CC_OP_EFLAGS;
4954
4955     svm_load_seg_cache(env->vm_vmcb + offsetof(struct vmcb, save.es),
4956                        env, R_ES);
4957     svm_load_seg_cache(env->vm_vmcb + offsetof(struct vmcb, save.cs),
4958                        env, R_CS);
4959     svm_load_seg_cache(env->vm_vmcb + offsetof(struct vmcb, save.ss),
4960                        env, R_SS);
4961     svm_load_seg_cache(env->vm_vmcb + offsetof(struct vmcb, save.ds),
4962                        env, R_DS);
4963
4964     EIP = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rip));
4965     env->eip = EIP;
4966     ESP = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rsp));
4967     EAX = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rax));
4968     env->dr[7] = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.dr7));
4969     env->dr[6] = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, save.dr6));
4970     cpu_x86_set_cpl(env, ldub_phys(env->vm_vmcb + offsetof(struct vmcb, save.cpl)));
4971
4972     /* FIXME: guest state consistency checks */
4973
4974     switch(ldub_phys(env->vm_vmcb + offsetof(struct vmcb, control.tlb_ctl))) {
4975         case TLB_CONTROL_DO_NOTHING:
4976             break;
4977         case TLB_CONTROL_FLUSH_ALL_ASID:
4978             /* FIXME: this is not 100% correct but should work for now */
4979             tlb_flush(env, 1);
4980         break;
4981     }
4982
4983     env->hflags2 |= HF2_GIF_MASK;
4984
4985     if (int_ctl & V_IRQ_MASK) {
4986         env->interrupt_request |= CPU_INTERRUPT_VIRQ;
4987     }
4988
4989     /* maybe we need to inject an event */
4990     event_inj = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.event_inj));
4991     if (event_inj & SVM_EVTINJ_VALID) {
4992         uint8_t vector = event_inj & SVM_EVTINJ_VEC_MASK;
4993         uint16_t valid_err = event_inj & SVM_EVTINJ_VALID_ERR;
4994         uint32_t event_inj_err = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.event_inj_err));
4995         stl_phys(env->vm_vmcb + offsetof(struct vmcb, control.event_inj), event_inj & ~SVM_EVTINJ_VALID);
4996
4997         qemu_log_mask(CPU_LOG_TB_IN_ASM, "Injecting(%#hx): ", valid_err);
4998         /* FIXME: need to implement valid_err */
4999         switch (event_inj & SVM_EVTINJ_TYPE_MASK) {
5000         case SVM_EVTINJ_TYPE_INTR:
5001                 env->exception_index = vector;
5002                 env->error_code = event_inj_err;
5003                 env->exception_is_int = 0;
5004                 env->exception_next_eip = -1;
5005                 qemu_log_mask(CPU_LOG_TB_IN_ASM, "INTR");
5006                 /* XXX: is it always correct ? */
5007                 do_interrupt(vector, 0, 0, 0, 1);
5008                 break;
5009         case SVM_EVTINJ_TYPE_NMI:
5010                 env->exception_index = EXCP02_NMI;
5011                 env->error_code = event_inj_err;
5012                 env->exception_is_int = 0;
5013                 env->exception_next_eip = EIP;
5014                 qemu_log_mask(CPU_LOG_TB_IN_ASM, "NMI");
5015                 cpu_loop_exit();
5016                 break;
5017         case SVM_EVTINJ_TYPE_EXEPT:
5018                 env->exception_index = vector;
5019                 env->error_code = event_inj_err;
5020                 env->exception_is_int = 0;
5021                 env->exception_next_eip = -1;
5022                 qemu_log_mask(CPU_LOG_TB_IN_ASM, "EXEPT");
5023                 cpu_loop_exit();
5024                 break;
5025         case SVM_EVTINJ_TYPE_SOFT:
5026                 env->exception_index = vector;
5027                 env->error_code = event_inj_err;
5028                 env->exception_is_int = 1;
5029                 env->exception_next_eip = EIP;
5030                 qemu_log_mask(CPU_LOG_TB_IN_ASM, "SOFT");
5031                 cpu_loop_exit();
5032                 break;
5033         }
5034         qemu_log_mask(CPU_LOG_TB_IN_ASM, " %#x %#x\n", env->exception_index, env->error_code);
5035     }
5036 }
5037
5038 void helper_vmmcall(void)
5039 {
5040     helper_svm_check_intercept_param(SVM_EXIT_VMMCALL, 0);
5041     raise_exception(EXCP06_ILLOP);
5042 }
5043
5044 void helper_vmload(int aflag)
5045 {
5046     target_ulong addr;
5047     helper_svm_check_intercept_param(SVM_EXIT_VMLOAD, 0);
5048
5049     if (aflag == 2)
5050         addr = EAX;
5051     else
5052         addr = (uint32_t)EAX;
5053
5054     qemu_log_mask(CPU_LOG_TB_IN_ASM, "vmload! " TARGET_FMT_lx "\nFS: %016" PRIx64 " | " TARGET_FMT_lx "\n",
5055                 addr, ldq_phys(addr + offsetof(struct vmcb, save.fs.base)),
5056                 env->segs[R_FS].base);
5057
5058     svm_load_seg_cache(addr + offsetof(struct vmcb, save.fs),
5059                        env, R_FS);
5060     svm_load_seg_cache(addr + offsetof(struct vmcb, save.gs),
5061                        env, R_GS);
5062     svm_load_seg(addr + offsetof(struct vmcb, save.tr),
5063                  &env->tr);
5064     svm_load_seg(addr + offsetof(struct vmcb, save.ldtr),
5065                  &env->ldt);
5066
5067 #ifdef TARGET_X86_64
5068     env->kernelgsbase = ldq_phys(addr + offsetof(struct vmcb, save.kernel_gs_base));
5069     env->lstar = ldq_phys(addr + offsetof(struct vmcb, save.lstar));
5070     env->cstar = ldq_phys(addr + offsetof(struct vmcb, save.cstar));
5071     env->fmask = ldq_phys(addr + offsetof(struct vmcb, save.sfmask));
5072 #endif
5073     env->star = ldq_phys(addr + offsetof(struct vmcb, save.star));
5074     env->sysenter_cs = ldq_phys(addr + offsetof(struct vmcb, save.sysenter_cs));
5075     env->sysenter_esp = ldq_phys(addr + offsetof(struct vmcb, save.sysenter_esp));
5076     env->sysenter_eip = ldq_phys(addr + offsetof(struct vmcb, save.sysenter_eip));
5077 }
5078
5079 void helper_vmsave(int aflag)
5080 {
5081     target_ulong addr;
5082     helper_svm_check_intercept_param(SVM_EXIT_VMSAVE, 0);
5083
5084     if (aflag == 2)
5085         addr = EAX;
5086     else
5087         addr = (uint32_t)EAX;
5088
5089     qemu_log_mask(CPU_LOG_TB_IN_ASM, "vmsave! " TARGET_FMT_lx "\nFS: %016" PRIx64 " | " TARGET_FMT_lx "\n",
5090                 addr, ldq_phys(addr + offsetof(struct vmcb, save.fs.base)),
5091                 env->segs[R_FS].base);
5092
5093     svm_save_seg(addr + offsetof(struct vmcb, save.fs),
5094                  &env->segs[R_FS]);
5095     svm_save_seg(addr + offsetof(struct vmcb, save.gs),
5096                  &env->segs[R_GS]);
5097     svm_save_seg(addr + offsetof(struct vmcb, save.tr),
5098                  &env->tr);
5099     svm_save_seg(addr + offsetof(struct vmcb, save.ldtr),
5100                  &env->ldt);
5101
5102 #ifdef TARGET_X86_64
5103     stq_phys(addr + offsetof(struct vmcb, save.kernel_gs_base), env->kernelgsbase);
5104     stq_phys(addr + offsetof(struct vmcb, save.lstar), env->lstar);
5105     stq_phys(addr + offsetof(struct vmcb, save.cstar), env->cstar);
5106     stq_phys(addr + offsetof(struct vmcb, save.sfmask), env->fmask);
5107 #endif
5108     stq_phys(addr + offsetof(struct vmcb, save.star), env->star);
5109     stq_phys(addr + offsetof(struct vmcb, save.sysenter_cs), env->sysenter_cs);
5110     stq_phys(addr + offsetof(struct vmcb, save.sysenter_esp), env->sysenter_esp);
5111     stq_phys(addr + offsetof(struct vmcb, save.sysenter_eip), env->sysenter_eip);
5112 }
5113
5114 void helper_stgi(void)
5115 {
5116     helper_svm_check_intercept_param(SVM_EXIT_STGI, 0);
5117     env->hflags2 |= HF2_GIF_MASK;
5118 }
5119
5120 void helper_clgi(void)
5121 {
5122     helper_svm_check_intercept_param(SVM_EXIT_CLGI, 0);
5123     env->hflags2 &= ~HF2_GIF_MASK;
5124 }
5125
5126 void helper_skinit(void)
5127 {
5128     helper_svm_check_intercept_param(SVM_EXIT_SKINIT, 0);
5129     /* XXX: not implemented */
5130     raise_exception(EXCP06_ILLOP);
5131 }
5132
5133 void helper_invlpga(int aflag)
5134 {
5135     target_ulong addr;
5136     helper_svm_check_intercept_param(SVM_EXIT_INVLPGA, 0);
5137
5138     if (aflag == 2)
5139         addr = EAX;
5140     else
5141         addr = (uint32_t)EAX;
5142
5143     /* XXX: could use the ASID to see if it is needed to do the
5144        flush */
5145     tlb_flush_page(env, addr);
5146 }
5147
5148 void helper_svm_check_intercept_param(uint32_t type, uint64_t param)
5149 {
5150     if (likely(!(env->hflags & HF_SVMI_MASK)))
5151         return;
5152     switch(type) {
5153     case SVM_EXIT_READ_CR0 ... SVM_EXIT_READ_CR0 + 8:
5154         if (env->intercept_cr_read & (1 << (type - SVM_EXIT_READ_CR0))) {
5155             helper_vmexit(type, param);
5156         }
5157         break;
5158     case SVM_EXIT_WRITE_CR0 ... SVM_EXIT_WRITE_CR0 + 8:
5159         if (env->intercept_cr_write & (1 << (type - SVM_EXIT_WRITE_CR0))) {
5160             helper_vmexit(type, param);
5161         }
5162         break;
5163     case SVM_EXIT_READ_DR0 ... SVM_EXIT_READ_DR0 + 7:
5164         if (env->intercept_dr_read & (1 << (type - SVM_EXIT_READ_DR0))) {
5165             helper_vmexit(type, param);
5166         }
5167         break;
5168     case SVM_EXIT_WRITE_DR0 ... SVM_EXIT_WRITE_DR0 + 7:
5169         if (env->intercept_dr_write & (1 << (type - SVM_EXIT_WRITE_DR0))) {
5170             helper_vmexit(type, param);
5171         }
5172         break;
5173     case SVM_EXIT_EXCP_BASE ... SVM_EXIT_EXCP_BASE + 31:
5174         if (env->intercept_exceptions & (1 << (type - SVM_EXIT_EXCP_BASE))) {
5175             helper_vmexit(type, param);
5176         }
5177         break;
5178     case SVM_EXIT_MSR:
5179         if (env->intercept & (1ULL << (SVM_EXIT_MSR - SVM_EXIT_INTR))) {
5180             /* FIXME: this should be read in at vmrun (faster this way?) */
5181             uint64_t addr = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, control.msrpm_base_pa));
5182             uint32_t t0, t1;
5183             switch((uint32_t)ECX) {
5184             case 0 ... 0x1fff:
5185                 t0 = (ECX * 2) % 8;
5186                 t1 = ECX / 8;
5187                 break;
5188             case 0xc0000000 ... 0xc0001fff:
5189                 t0 = (8192 + ECX - 0xc0000000) * 2;
5190                 t1 = (t0 / 8);
5191                 t0 %= 8;
5192                 break;
5193             case 0xc0010000 ... 0xc0011fff:
5194                 t0 = (16384 + ECX - 0xc0010000) * 2;
5195                 t1 = (t0 / 8);
5196                 t0 %= 8;
5197                 break;
5198             default:
5199                 helper_vmexit(type, param);
5200                 t0 = 0;
5201                 t1 = 0;
5202                 break;
5203             }
5204             if (ldub_phys(addr + t1) & ((1 << param) << t0))
5205                 helper_vmexit(type, param);
5206         }
5207         break;
5208     default:
5209         if (env->intercept & (1ULL << (type - SVM_EXIT_INTR))) {
5210             helper_vmexit(type, param);
5211         }
5212         break;
5213     }
5214 }
5215
5216 void helper_svm_check_io(uint32_t port, uint32_t param,
5217                          uint32_t next_eip_addend)
5218 {
5219     if (env->intercept & (1ULL << (SVM_EXIT_IOIO - SVM_EXIT_INTR))) {
5220         /* FIXME: this should be read in at vmrun (faster this way?) */
5221         uint64_t addr = ldq_phys(env->vm_vmcb + offsetof(struct vmcb, control.iopm_base_pa));
5222         uint16_t mask = (1 << ((param >> 4) & 7)) - 1;
5223         if(lduw_phys(addr + port / 8) & (mask << (port & 7))) {
5224             /* next EIP */
5225             stq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_info_2),
5226                      env->eip + next_eip_addend);
5227             helper_vmexit(SVM_EXIT_IOIO, param | (port << 16));
5228         }
5229     }
5230 }
5231
5232 /* Note: currently only 32 bits of exit_code are used */
5233 void helper_vmexit(uint32_t exit_code, uint64_t exit_info_1)
5234 {
5235     uint32_t int_ctl;
5236
5237     qemu_log_mask(CPU_LOG_TB_IN_ASM, "vmexit(%08x, %016" PRIx64 ", %016" PRIx64 ", " TARGET_FMT_lx ")!\n",
5238                 exit_code, exit_info_1,
5239                 ldq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_info_2)),
5240                 EIP);
5241
5242     if(env->hflags & HF_INHIBIT_IRQ_MASK) {
5243         stl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_state), SVM_INTERRUPT_SHADOW_MASK);
5244         env->hflags &= ~HF_INHIBIT_IRQ_MASK;
5245     } else {
5246         stl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_state), 0);
5247     }
5248
5249     /* Save the VM state in the vmcb */
5250     svm_save_seg(env->vm_vmcb + offsetof(struct vmcb, save.es),
5251                  &env->segs[R_ES]);
5252     svm_save_seg(env->vm_vmcb + offsetof(struct vmcb, save.cs),
5253                  &env->segs[R_CS]);
5254     svm_save_seg(env->vm_vmcb + offsetof(struct vmcb, save.ss),
5255                  &env->segs[R_SS]);
5256     svm_save_seg(env->vm_vmcb + offsetof(struct vmcb, save.ds),
5257                  &env->segs[R_DS]);
5258
5259     stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.gdtr.base), env->gdt.base);
5260     stl_phys(env->vm_vmcb + offsetof(struct vmcb, save.gdtr.limit), env->gdt.limit);
5261
5262     stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.idtr.base), env->idt.base);
5263     stl_phys(env->vm_vmcb + offsetof(struct vmcb, save.idtr.limit), env->idt.limit);
5264
5265     stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.efer), env->efer);
5266     stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr0), env->cr[0]);
5267     stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr2), env->cr[2]);
5268     stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr3), env->cr[3]);
5269     stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.cr4), env->cr[4]);
5270
5271     int_ctl = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_ctl));
5272     int_ctl &= ~(V_TPR_MASK | V_IRQ_MASK);
5273     int_ctl |= env->v_tpr & V_TPR_MASK;
5274     if (env->interrupt_request & CPU_INTERRUPT_VIRQ)
5275         int_ctl |= V_IRQ_MASK;
5276     stl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_ctl), int_ctl);
5277
5278     stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rflags), compute_eflags());
5279     stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rip), env->eip);
5280     stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rsp), ESP);
5281     stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.rax), EAX);
5282     stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.dr7), env->dr[7]);
5283     stq_phys(env->vm_vmcb + offsetof(struct vmcb, save.dr6), env->dr[6]);
5284     stb_phys(env->vm_vmcb + offsetof(struct vmcb, save.cpl), env->hflags & HF_CPL_MASK);
5285
5286     /* Reload the host state from vm_hsave */
5287     env->hflags2 &= ~(HF2_HIF_MASK | HF2_VINTR_MASK);
5288     env->hflags &= ~HF_SVMI_MASK;
5289     env->intercept = 0;
5290     env->intercept_exceptions = 0;
5291     env->interrupt_request &= ~CPU_INTERRUPT_VIRQ;
5292     env->tsc_offset = 0;
5293
5294     env->gdt.base  = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.gdtr.base));
5295     env->gdt.limit = ldl_phys(env->vm_hsave + offsetof(struct vmcb, save.gdtr.limit));
5296
5297     env->idt.base  = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.idtr.base));
5298     env->idt.limit = ldl_phys(env->vm_hsave + offsetof(struct vmcb, save.idtr.limit));
5299
5300     cpu_x86_update_cr0(env, ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr0)) | CR0_PE_MASK);
5301     cpu_x86_update_cr4(env, ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr4)));
5302     cpu_x86_update_cr3(env, ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.cr3)));
5303     /* we need to set the efer after the crs so the hidden flags get
5304        set properly */
5305     cpu_load_efer(env,
5306                   ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.efer)));
5307     env->eflags = 0;
5308     load_eflags(ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.rflags)),
5309                 ~(CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C | DF_MASK));
5310     CC_OP = CC_OP_EFLAGS;
5311
5312     svm_load_seg_cache(env->vm_hsave + offsetof(struct vmcb, save.es),
5313                        env, R_ES);
5314     svm_load_seg_cache(env->vm_hsave + offsetof(struct vmcb, save.cs),
5315                        env, R_CS);
5316     svm_load_seg_cache(env->vm_hsave + offsetof(struct vmcb, save.ss),
5317                        env, R_SS);
5318     svm_load_seg_cache(env->vm_hsave + offsetof(struct vmcb, save.ds),
5319                        env, R_DS);
5320
5321     EIP = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.rip));
5322     ESP = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.rsp));
5323     EAX = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.rax));
5324
5325     env->dr[6] = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.dr6));
5326     env->dr[7] = ldq_phys(env->vm_hsave + offsetof(struct vmcb, save.dr7));
5327
5328     /* other setups */
5329     cpu_x86_set_cpl(env, 0);
5330     stq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_code), exit_code);
5331     stq_phys(env->vm_vmcb + offsetof(struct vmcb, control.exit_info_1), exit_info_1);
5332
5333     env->hflags2 &= ~HF2_GIF_MASK;
5334     /* FIXME: Resets the current ASID register to zero (host ASID). */
5335
5336     /* Clears the V_IRQ and V_INTR_MASKING bits inside the processor. */
5337
5338     /* Clears the TSC_OFFSET inside the processor. */
5339
5340     /* If the host is in PAE mode, the processor reloads the host's PDPEs
5341        from the page table indicated the host's CR3. If the PDPEs contain
5342        illegal state, the processor causes a shutdown. */
5343
5344     /* Forces CR0.PE = 1, RFLAGS.VM = 0. */
5345     env->cr[0] |= CR0_PE_MASK;
5346     env->eflags &= ~VM_MASK;
5347
5348     /* Disables all breakpoints in the host DR7 register. */
5349
5350     /* Checks the reloaded host state for consistency. */
5351
5352     /* If the host's rIP reloaded by #VMEXIT is outside the limit of the
5353        host's code segment or non-canonical (in the case of long mode), a
5354        #GP fault is delivered inside the host.) */
5355
5356     /* remove any pending exception */
5357     env->exception_index = -1;
5358     env->error_code = 0;
5359     env->old_exception = -1;
5360
5361     cpu_loop_exit();
5362 }
5363
5364 #endif
5365
5366 /* MMX/SSE */
5367 /* XXX: optimize by storing fptt and fptags in the static cpu state */
5368 void helper_enter_mmx(void)
5369 {
5370     env->fpstt = 0;
5371     *(uint32_t *)(env->fptags) = 0;
5372     *(uint32_t *)(env->fptags + 4) = 0;
5373 }
5374
5375 void helper_emms(void)
5376 {
5377     /* set to empty state */
5378     *(uint32_t *)(env->fptags) = 0x01010101;
5379     *(uint32_t *)(env->fptags + 4) = 0x01010101;
5380 }
5381
5382 /* XXX: suppress */
5383 void helper_movq(void *d, void *s)
5384 {
5385     *(uint64_t *)d = *(uint64_t *)s;
5386 }
5387
5388 #define SHIFT 0
5389 #include "ops_sse.h"
5390
5391 #define SHIFT 1
5392 #include "ops_sse.h"
5393
5394 #define SHIFT 0
5395 #include "helper_template.h"
5396 #undef SHIFT
5397
5398 #define SHIFT 1
5399 #include "helper_template.h"
5400 #undef SHIFT
5401
5402 #define SHIFT 2
5403 #include "helper_template.h"
5404 #undef SHIFT
5405
5406 #ifdef TARGET_X86_64
5407
5408 #define SHIFT 3
5409 #include "helper_template.h"
5410 #undef SHIFT
5411
5412 #endif
5413
5414 /* bit operations */
5415 target_ulong helper_bsf(target_ulong t0)
5416 {
5417     int count;
5418     target_ulong res;
5419
5420     res = t0;
5421     count = 0;
5422     while ((res & 1) == 0) {
5423         count++;
5424         res >>= 1;
5425     }
5426     return count;
5427 }
5428
5429 target_ulong helper_bsr(target_ulong t0)
5430 {
5431     int count;
5432     target_ulong res, mask;
5433
5434     res = t0;
5435     count = TARGET_LONG_BITS - 1;
5436     mask = (target_ulong)1 << (TARGET_LONG_BITS - 1);
5437     while ((res & mask) == 0) {
5438         count--;
5439         res <<= 1;
5440     }
5441     return count;
5442 }
5443
5444
5445 static int compute_all_eflags(void)
5446 {
5447     return CC_SRC;
5448 }
5449
5450 static int compute_c_eflags(void)
5451 {
5452     return CC_SRC & CC_C;
5453 }
5454
5455 uint32_t helper_cc_compute_all(int op)
5456 {
5457     switch (op) {
5458     default: /* should never happen */ return 0;
5459
5460     case CC_OP_EFLAGS: return compute_all_eflags();
5461
5462     case CC_OP_MULB: return compute_all_mulb();
5463     case CC_OP_MULW: return compute_all_mulw();
5464     case CC_OP_MULL: return compute_all_mull();
5465
5466     case CC_OP_ADDB: return compute_all_addb();
5467     case CC_OP_ADDW: return compute_all_addw();
5468     case CC_OP_ADDL: return compute_all_addl();
5469
5470     case CC_OP_ADCB: return compute_all_adcb();
5471     case CC_OP_ADCW: return compute_all_adcw();
5472     case CC_OP_ADCL: return compute_all_adcl();
5473
5474     case CC_OP_SUBB: return compute_all_subb();
5475     case CC_OP_SUBW: return compute_all_subw();
5476     case CC_OP_SUBL: return compute_all_subl();
5477
5478     case CC_OP_SBBB: return compute_all_sbbb();
5479     case CC_OP_SBBW: return compute_all_sbbw();
5480     case CC_OP_SBBL: return compute_all_sbbl();
5481
5482     case CC_OP_LOGICB: return compute_all_logicb();
5483     case CC_OP_LOGICW: return compute_all_logicw();
5484     case CC_OP_LOGICL: return compute_all_logicl();
5485
5486     case CC_OP_INCB: return compute_all_incb();
5487     case CC_OP_INCW: return compute_all_incw();
5488     case CC_OP_INCL: return compute_all_incl();
5489
5490     case CC_OP_DECB: return compute_all_decb();
5491     case CC_OP_DECW: return compute_all_decw();
5492     case CC_OP_DECL: return compute_all_decl();
5493
5494     case CC_OP_SHLB: return compute_all_shlb();
5495     case CC_OP_SHLW: return compute_all_shlw();
5496     case CC_OP_SHLL: return compute_all_shll();
5497
5498     case CC_OP_SARB: return compute_all_sarb();
5499     case CC_OP_SARW: return compute_all_sarw();
5500     case CC_OP_SARL: return compute_all_sarl();
5501
5502 #ifdef TARGET_X86_64
5503     case CC_OP_MULQ: return compute_all_mulq();
5504
5505     case CC_OP_ADDQ: return compute_all_addq();
5506
5507     case CC_OP_ADCQ: return compute_all_adcq();
5508
5509     case CC_OP_SUBQ: return compute_all_subq();
5510
5511     case CC_OP_SBBQ: return compute_all_sbbq();
5512
5513     case CC_OP_LOGICQ: return compute_all_logicq();
5514
5515     case CC_OP_INCQ: return compute_all_incq();
5516
5517     case CC_OP_DECQ: return compute_all_decq();
5518
5519     case CC_OP_SHLQ: return compute_all_shlq();
5520
5521     case CC_OP_SARQ: return compute_all_sarq();
5522 #endif
5523     }
5524 }
5525
5526 uint32_t helper_cc_compute_c(int op)
5527 {
5528     switch (op) {
5529     default: /* should never happen */ return 0;
5530
5531     case CC_OP_EFLAGS: return compute_c_eflags();
5532
5533     case CC_OP_MULB: return compute_c_mull();
5534     case CC_OP_MULW: return compute_c_mull();
5535     case CC_OP_MULL: return compute_c_mull();
5536
5537     case CC_OP_ADDB: return compute_c_addb();
5538     case CC_OP_ADDW: return compute_c_addw();
5539     case CC_OP_ADDL: return compute_c_addl();
5540
5541     case CC_OP_ADCB: return compute_c_adcb();
5542     case CC_OP_ADCW: return compute_c_adcw();
5543     case CC_OP_ADCL: return compute_c_adcl();
5544
5545     case CC_OP_SUBB: return compute_c_subb();
5546     case CC_OP_SUBW: return compute_c_subw();
5547     case CC_OP_SUBL: return compute_c_subl();
5548
5549     case CC_OP_SBBB: return compute_c_sbbb();
5550     case CC_OP_SBBW: return compute_c_sbbw();
5551     case CC_OP_SBBL: return compute_c_sbbl();
5552
5553     case CC_OP_LOGICB: return compute_c_logicb();
5554     case CC_OP_LOGICW: return compute_c_logicw();
5555     case CC_OP_LOGICL: return compute_c_logicl();
5556
5557     case CC_OP_INCB: return compute_c_incl();
5558     case CC_OP_INCW: return compute_c_incl();
5559     case CC_OP_INCL: return compute_c_incl();
5560
5561     case CC_OP_DECB: return compute_c_incl();
5562     case CC_OP_DECW: return compute_c_incl();
5563     case CC_OP_DECL: return compute_c_incl();
5564
5565     case CC_OP_SHLB: return compute_c_shlb();
5566     case CC_OP_SHLW: return compute_c_shlw();
5567     case CC_OP_SHLL: return compute_c_shll();
5568
5569     case CC_OP_SARB: return compute_c_sarl();
5570     case CC_OP_SARW: return compute_c_sarl();
5571     case CC_OP_SARL: return compute_c_sarl();
5572
5573 #ifdef TARGET_X86_64
5574     case CC_OP_MULQ: return compute_c_mull();
5575
5576     case CC_OP_ADDQ: return compute_c_addq();
5577
5578     case CC_OP_ADCQ: return compute_c_adcq();
5579
5580     case CC_OP_SUBQ: return compute_c_subq();
5581
5582     case CC_OP_SBBQ: return compute_c_sbbq();
5583
5584     case CC_OP_LOGICQ: return compute_c_logicq();
5585
5586     case CC_OP_INCQ: return compute_c_incl();
5587
5588     case CC_OP_DECQ: return compute_c_incl();
5589
5590     case CC_OP_SHLQ: return compute_c_shlq();
5591
5592     case CC_OP_SARQ: return compute_c_sarl();
5593 #endif
5594     }
5595 }