target/i386/hvf/x86_emu.c

   1 /*
   2  * Copyright (C) 2016 Veertu Inc,
   3  * Copyright (C) 2017 Google Inc,
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 /////////////////////////////////////////////////////////////////////////
  20 //
  21 //  Copyright (C) 2001-2012  The Bochs Project
  22 //
  23 //  This library is free software; you can redistribute it and/or
  24 //  modify it under the terms of the GNU Lesser General Public
  25 //  License as published by the Free Software Foundation; either
  26 //  version 2 of the License, or (at your option) any later version.
  27 //
  28 //  This library is distributed in the hope that it will be useful,
  29 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  30 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  31 //  Lesser General Public License for more details.
  32 //
  33 //  You should have received a copy of the GNU Lesser General Public
  34 //  License along with this library; if not, write to the Free Software
  35 //  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA B 02110-1301 USA
  36 /////////////////////////////////////////////////////////////////////////
  37
  38 #include "qemu/osdep.h"
  39
  40 #include "qemu-common.h"
  41 #include "x86_decode.h"
  42 #include "x86.h"
  43 #include "x86_emu.h"
  44 #include "x86_mmu.h"
  45 #include "x86_flags.h"
  46 #include "vmcs.h"
  47 #include "vmx.h"
  48
  49 void hvf_handle_io(struct CPUState *cpu, uint16_t port, void *data,
  50                    int direction, int size, uint32_t count);
  51
  52 #define EXEC_2OP_LOGIC_CMD(env, decode, cmd, FLAGS_FUNC, save_res) \
  53 {                                                       \
  54     fetch_operands(env, decode, 2, true, true, false);  \
  55     switch (decode->operand_size) {                     \
  56     case 1:                                         \
  57     {                                               \
  58         uint8_t v1 = (uint8_t)decode->op[0].val;    \
  59         uint8_t v2 = (uint8_t)decode->op[1].val;    \
  60         uint8_t diff = v1 cmd v2;                   \
  61         if (save_res) {                              \
  62             write_val_ext(env, decode->op[0].ptr, diff, 1);  \
  63         } \
  64         FLAGS_FUNC##_8(diff);                       \
  65         break;                                      \
  66     }                                               \
  67     case 2:                                        \
  68     {                                               \
  69         uint16_t v1 = (uint16_t)decode->op[0].val;  \
  70         uint16_t v2 = (uint16_t)decode->op[1].val;  \
  71         uint16_t diff = v1 cmd v2;                  \
  72         if (save_res) {                              \
  73             write_val_ext(env, decode->op[0].ptr, diff, 2); \
  74         } \
  75         FLAGS_FUNC##_16(diff);                      \
  76         break;                                      \
  77     }                                               \
  78     case 4:                                        \
  79     {                                               \
  80         uint32_t v1 = (uint32_t)decode->op[0].val;  \
  81         uint32_t v2 = (uint32_t)decode->op[1].val;  \
  82         uint32_t diff = v1 cmd v2;                  \
  83         if (save_res) {                              \
  84             write_val_ext(env, decode->op[0].ptr, diff, 4); \
  85         } \
  86         FLAGS_FUNC##_32(diff);                      \
  87         break;                                      \
  88     }                                               \
  89     default:                                        \
  90         VM_PANIC("bad size\n");                    \
  91     }                                                   \
  92 }                                                       \
  93
  94
  95 #define EXEC_2OP_ARITH_CMD(env, decode, cmd, FLAGS_FUNC, save_res) \
  96 {                                                       \
  97     fetch_operands(env, decode, 2, true, true, false);  \
  98     switch (decode->operand_size) {                     \
  99     case 1:                                         \
 100     {                                               \
 101         uint8_t v1 = (uint8_t)decode->op[0].val;    \
 102         uint8_t v2 = (uint8_t)decode->op[1].val;    \
 103         uint8_t diff = v1 cmd v2;                   \
 104         if (save_res) {                              \
 105             write_val_ext(env, decode->op[0].ptr, diff, 1);  \
 106         } \
 107         FLAGS_FUNC##_8(v1, v2, diff);               \
 108         break;                                      \
 109     }                                               \
 110     case 2:                                        \
 111     {                                               \
 112         uint16_t v1 = (uint16_t)decode->op[0].val;  \
 113         uint16_t v2 = (uint16_t)decode->op[1].val;  \
 114         uint16_t diff = v1 cmd v2;                  \
 115         if (save_res) {                              \
 116             write_val_ext(env, decode->op[0].ptr, diff, 2); \
 117         } \
 118         FLAGS_FUNC##_16(v1, v2, diff);              \
 119         break;                                      \
 120     }                                               \
 121     case 4:                                        \
 122     {                                               \
 123         uint32_t v1 = (uint32_t)decode->op[0].val;  \
 124         uint32_t v2 = (uint32_t)decode->op[1].val;  \
 125         uint32_t diff = v1 cmd v2;                  \
 126         if (save_res) {                              \
 127             write_val_ext(env, decode->op[0].ptr, diff, 4); \
 128         } \
 129         FLAGS_FUNC##_32(v1, v2, diff);              \
 130         break;                                      \
 131     }                                               \
 132     default:                                        \
 133         VM_PANIC("bad size\n");                    \
 134     }                                                   \
 135 }
 136
 137 addr_t read_reg(CPUX86State *env, int reg, int size)
 138 {
 139     switch (size) {
 140     case 1:
 141         return env->hvf_emul->regs[reg].lx;
 142     case 2:
 143         return env->hvf_emul->regs[reg].rx;
 144     case 4:
 145         return env->hvf_emul->regs[reg].erx;
 146     case 8:
 147         return env->hvf_emul->regs[reg].rrx;
 148     default:
 149         VM_PANIC_ON("read_reg size");
 150     }
 151     return 0;
 152 }
 153
 154 void write_reg(CPUX86State *env, int reg, addr_t val, int size)
 155 {
 156     switch (size) {
 157     case 1:
 158         env->hvf_emul->regs[reg].lx = val;
 159         break;
 160     case 2:
 161         env->hvf_emul->regs[reg].rx = val;
 162         break;
 163     case 4:
 164         env->hvf_emul->regs[reg].rrx = (uint32_t)val;
 165         break;
 166     case 8:
 167         env->hvf_emul->regs[reg].rrx = val;
 168         break;
 169     default:
 170         VM_PANIC_ON("write_reg size");
 171     }
 172 }
 173
 174 addr_t read_val_from_reg(addr_t reg_ptr, int size)
 175 {
 176     addr_t val;
 177
 178     switch (size) {
 179     case 1:
 180         val = *(uint8_t *)reg_ptr;
 181         break;
 182     case 2:
 183         val = *(uint16_t *)reg_ptr;
 184         break;
 185     case 4:
 186         val = *(uint32_t *)reg_ptr;
 187         break;
 188     case 8:
 189         val = *(uint64_t *)reg_ptr;
 190         break;
 191     default:
 192         VM_PANIC_ON_EX(1, "read_val: Unknown size %d\n", size);
 193         break;
 194     }
 195     return val;
 196 }
 197
 198 void write_val_to_reg(addr_t reg_ptr, addr_t val, int size)
 199 {
 200     switch (size) {
 201     case 1:
 202         *(uint8_t *)reg_ptr = val;
 203         break;
 204     case 2:
 205         *(uint16_t *)reg_ptr = val;
 206         break;
 207     case 4:
 208         *(uint64_t *)reg_ptr = (uint32_t)val;
 209         break;
 210     case 8:
 211         *(uint64_t *)reg_ptr = val;
 212         break;
 213     default:
 214         VM_PANIC("write_val: Unknown size\n");
 215         break;
 216     }
 217 }
 218
 219 static bool is_host_reg(struct CPUX86State *env, addr_t ptr)
 220 {
 221     return (ptr - (addr_t)&env->hvf_emul->regs[0]) < sizeof(env->hvf_emul->regs);
 222 }
 223
 224 void write_val_ext(struct CPUX86State *env, addr_t ptr, addr_t val, int size)
 225 {
 226     if (is_host_reg(env, ptr)) {
 227         write_val_to_reg(ptr, val, size);
 228         return;
 229     }
 230     vmx_write_mem(ENV_GET_CPU(env), ptr, &val, size);
 231 }
 232
 233 uint8_t *read_mmio(struct CPUX86State *env, addr_t ptr, int bytes)
 234 {
 235     vmx_read_mem(ENV_GET_CPU(env), env->hvf_emul->mmio_buf, ptr, bytes);
 236     return env->hvf_emul->mmio_buf;
 237 }
 238
 239
 240 addr_t read_val_ext(struct CPUX86State *env, addr_t ptr, int size)
 241 {
 242     addr_t val;
 243     uint8_t *mmio_ptr;
 244
 245     if (is_host_reg(env, ptr)) {
 246         return read_val_from_reg(ptr, size);
 247     }
 248
 249     mmio_ptr = read_mmio(env, ptr, size);
 250     switch (size) {
 251     case 1:
 252         val = *(uint8_t *)mmio_ptr;
 253         break;
 254     case 2:
 255         val = *(uint16_t *)mmio_ptr;
 256         break;
 257     case 4:
 258         val = *(uint32_t *)mmio_ptr;
 259         break;
 260     case 8:
 261         val = *(uint64_t *)mmio_ptr;
 262         break;
 263     default:
 264         VM_PANIC("bad size\n");
 265         break;
 266     }
 267     return val;
 268 }
 269
 270 static void fetch_operands(struct CPUX86State *env, struct x86_decode *decode,
 271                            int n, bool val_op0, bool val_op1, bool val_op2)
 272 {
 273     int i;
 274     bool calc_val[3] = {val_op0, val_op1, val_op2};
 275
 276     for (i = 0; i < n; i++) {
 277         switch (decode->op[i].type) {
 278         case X86_VAR_IMMEDIATE:
 279             break;
 280         case X86_VAR_REG:
 281             VM_PANIC_ON(!decode->op[i].ptr);
 282             if (calc_val[i]) {
 283                 decode->op[i].val = read_val_from_reg(decode->op[i].ptr,
 284                                                       decode->operand_size);
 285             }
 286             break;
 287         case X86_VAR_RM:
 288             calc_modrm_operand(env, decode, &decode->op[i]);
 289             if (calc_val[i]) {
 290                 decode->op[i].val = read_val_ext(env, decode->op[i].ptr,
 291                                                  decode->operand_size);
 292             }
 293             break;
 294         case X86_VAR_OFFSET:
 295             decode->op[i].ptr = decode_linear_addr(env, decode,
 296                                                    decode->op[i].ptr,
 297                                                    REG_SEG_DS);
 298             if (calc_val[i]) {
 299                 decode->op[i].val = read_val_ext(env, decode->op[i].ptr,
 300                                                  decode->operand_size);
 301             }
 302             break;
 303         default:
 304             break;
 305         }
 306     }
 307 }
 308
 309 static void exec_mov(struct CPUX86State *env, struct x86_decode *decode)
 310 {
 311     fetch_operands(env, decode, 2, false, true, false);
 312     write_val_ext(env, decode->op[0].ptr, decode->op[1].val,
 313                   decode->operand_size);
 314
 315     RIP(env) += decode->len;
 316 }
 317
 318 static void exec_add(struct CPUX86State *env, struct x86_decode *decode)
 319 {
 320     EXEC_2OP_ARITH_CMD(env, decode, +, SET_FLAGS_OSZAPC_ADD, true);
 321     RIP(env) += decode->len;
 322 }
 323
 324 static void exec_or(struct CPUX86State *env, struct x86_decode *decode)
 325 {
 326     EXEC_2OP_LOGIC_CMD(env, decode, |, SET_FLAGS_OSZAPC_LOGIC, true);
 327     RIP(env) += decode->len;
 328 }
 329
 330 static void exec_adc(struct CPUX86State *env, struct x86_decode *decode)
 331 {
 332     EXEC_2OP_ARITH_CMD(env, decode, +get_CF(env)+, SET_FLAGS_OSZAPC_ADD, true);
 333     RIP(env) += decode->len;
 334 }
 335
 336 static void exec_sbb(struct CPUX86State *env, struct x86_decode *decode)
 337 {
 338     EXEC_2OP_ARITH_CMD(env, decode, -get_CF(env)-, SET_FLAGS_OSZAPC_SUB, true);
 339     RIP(env) += decode->len;
 340 }
 341
 342 static void exec_and(struct CPUX86State *env, struct x86_decode *decode)
 343 {
 344     EXEC_2OP_LOGIC_CMD(env, decode, &, SET_FLAGS_OSZAPC_LOGIC, true);
 345     RIP(env) += decode->len;
 346 }
 347
 348 static void exec_sub(struct CPUX86State *env, struct x86_decode *decode)
 349 {
 350     EXEC_2OP_ARITH_CMD(env, decode, -, SET_FLAGS_OSZAPC_SUB, true);
 351     RIP(env) += decode->len;
 352 }
 353
 354 static void exec_xor(struct CPUX86State *env, struct x86_decode *decode)
 355 {
 356     EXEC_2OP_LOGIC_CMD(env, decode, ^, SET_FLAGS_OSZAPC_LOGIC, true);
 357     RIP(env) += decode->len;
 358 }
 359
 360 static void exec_neg(struct CPUX86State *env, struct x86_decode *decode)
 361 {
 362     /*EXEC_2OP_ARITH_CMD(env, decode, -, SET_FLAGS_OSZAPC_SUB, false);*/
 363     int32_t val;
 364     fetch_operands(env, decode, 2, true, true, false);
 365
 366     val = 0 - sign(decode->op[1].val, decode->operand_size);
 367     write_val_ext(env, decode->op[1].ptr, val, decode->operand_size);
 368
 369     if (4 == decode->operand_size) {
 370         SET_FLAGS_OSZAPC_SUB_32(0, 0 - val, val);
 371     } else if (2 == decode->operand_size) {
 372         SET_FLAGS_OSZAPC_SUB_16(0, 0 - val, val);
 373     } else if (1 == decode->operand_size) {
 374         SET_FLAGS_OSZAPC_SUB_8(0, 0 - val, val);
 375     } else {
 376         VM_PANIC("bad op size\n");
 377     }
 378
 379     /*lflags_to_rflags(env);*/
 380     RIP(env) += decode->len;
 381 }
 382
 383 static void exec_cmp(struct CPUX86State *env, struct x86_decode *decode)
 384 {
 385     EXEC_2OP_ARITH_CMD(env, decode, -, SET_FLAGS_OSZAPC_SUB, false);
 386     RIP(env) += decode->len;
 387 }
 388
 389 static void exec_inc(struct CPUX86State *env, struct x86_decode *decode)
 390 {
 391     decode->op[1].type = X86_VAR_IMMEDIATE;
 392     decode->op[1].val = 0;
 393
 394     EXEC_2OP_ARITH_CMD(env, decode, +1+, SET_FLAGS_OSZAP_ADD, true);
 395
 396     RIP(env) += decode->len;
 397 }
 398
 399 static void exec_dec(struct CPUX86State *env, struct x86_decode *decode)
 400 {
 401     decode->op[1].type = X86_VAR_IMMEDIATE;
 402     decode->op[1].val = 0;
 403
 404     EXEC_2OP_ARITH_CMD(env, decode, -1-, SET_FLAGS_OSZAP_SUB, true);
 405     RIP(env) += decode->len;
 406 }
 407
 408 static void exec_tst(struct CPUX86State *env, struct x86_decode *decode)
 409 {
 410     EXEC_2OP_LOGIC_CMD(env, decode, &, SET_FLAGS_OSZAPC_LOGIC, false);
 411     RIP(env) += decode->len;
 412 }
 413
 414 static void exec_not(struct CPUX86State *env, struct x86_decode *decode)
 415 {
 416     fetch_operands(env, decode, 1, true, false, false);
 417
 418     write_val_ext(env, decode->op[0].ptr, ~decode->op[0].val,
 419                   decode->operand_size);
 420     RIP(env) += decode->len;
 421 }
 422
 423 void exec_movzx(struct CPUX86State *env, struct x86_decode *decode)
 424 {
 425     int src_op_size;
 426     int op_size = decode->operand_size;
 427
 428     fetch_operands(env, decode, 1, false, false, false);
 429
 430     if (0xb6 == decode->opcode[1]) {
 431         src_op_size = 1;
 432     } else {
 433         src_op_size = 2;
 434     }
 435     decode->operand_size = src_op_size;
 436     calc_modrm_operand(env, decode, &decode->op[1]);
 437     decode->op[1].val = read_val_ext(env, decode->op[1].ptr, src_op_size);
 438     write_val_ext(env, decode->op[0].ptr, decode->op[1].val, op_size);
 439
 440     RIP(env) += decode->len;
 441 }
 442
 443 static void exec_out(struct CPUX86State *env, struct x86_decode *decode)
 444 {
 445     switch (decode->opcode[0]) {
 446     case 0xe6:
 447         hvf_handle_io(ENV_GET_CPU(env), decode->op[0].val, &AL(env), 1, 1, 1);
 448         break;
 449     case 0xe7:
 450         hvf_handle_io(ENV_GET_CPU(env), decode->op[0].val, &RAX(env), 1,
 451                       decode->operand_size, 1);
 452         break;
 453     case 0xee:
 454         hvf_handle_io(ENV_GET_CPU(env), DX(env), &AL(env), 1, 1, 1);
 455         break;
 456     case 0xef:
 457         hvf_handle_io(ENV_GET_CPU(env), DX(env), &RAX(env), 1, decode->operand_size, 1);
 458         break;
 459     default:
 460         VM_PANIC("Bad out opcode\n");
 461         break;
 462     }
 463     RIP(env) += decode->len;
 464 }
 465
 466 static void exec_in(struct CPUX86State *env, struct x86_decode *decode)
 467 {
 468     addr_t val = 0;
 469     switch (decode->opcode[0]) {
 470     case 0xe4:
 471         hvf_handle_io(ENV_GET_CPU(env), decode->op[0].val, &AL(env), 0, 1, 1);
 472         break;
 473     case 0xe5:
 474         hvf_handle_io(ENV_GET_CPU(env), decode->op[0].val, &val, 0, decode->operand_size, 1);
 475         if (decode->operand_size == 2) {
 476             AX(env) = val;
 477         } else {
 478             RAX(env) = (uint32_t)val;
 479         }
 480         break;
 481     case 0xec:
 482         hvf_handle_io(ENV_GET_CPU(env), DX(env), &AL(env), 0, 1, 1);
 483         break;
 484     case 0xed:
 485         hvf_handle_io(ENV_GET_CPU(env), DX(env), &val, 0, decode->operand_size, 1);
 486         if (decode->operand_size == 2) {
 487             AX(env) = val;
 488         } else {
 489             RAX(env) = (uint32_t)val;
 490         }
 491
 492         break;
 493     default:
 494         VM_PANIC("Bad in opcode\n");
 495         break;
 496     }
 497
 498     RIP(env) += decode->len;
 499 }
 500
 501 static inline void string_increment_reg(struct CPUX86State *env, int reg,
 502                                         struct x86_decode *decode)
 503 {
 504     addr_t val = read_reg(env, reg, decode->addressing_size);
 505     if (env->hvf_emul->rflags.df) {
 506         val -= decode->operand_size;
 507     } else {
 508         val += decode->operand_size;
 509     }
 510     write_reg(env, reg, val, decode->addressing_size);
 511 }
 512
 513 static inline void string_rep(struct CPUX86State *env, struct x86_decode *decode,
 514                               void (*func)(struct CPUX86State *env,
 515                                            struct x86_decode *ins), int rep)
 516 {
 517     addr_t rcx = read_reg(env, REG_RCX, decode->addressing_size);
 518     while (rcx--) {
 519         func(env, decode);
 520         write_reg(env, REG_RCX, rcx, decode->addressing_size);
 521         if ((PREFIX_REP == rep) && !get_ZF(env)) {
 522             break;
 523         }
 524         if ((PREFIX_REPN == rep) && get_ZF(env)) {
 525             break;
 526         }
 527     }
 528 }
 529
 530 static void exec_ins_single(struct CPUX86State *env, struct x86_decode *decode)
 531 {
 532     addr_t addr = linear_addr_size(ENV_GET_CPU(env), RDI(env), decode->addressing_size,
 533                                    REG_SEG_ES);
 534
 535     hvf_handle_io(ENV_GET_CPU(env), DX(env), env->hvf_emul->mmio_buf, 0,
 536                   decode->operand_size, 1);
 537     vmx_write_mem(ENV_GET_CPU(env), addr, env->hvf_emul->mmio_buf, decode->operand_size);
 538
 539     string_increment_reg(env, REG_RDI, decode);
 540 }
 541
 542 static void exec_ins(struct CPUX86State *env, struct x86_decode *decode)
 543 {
 544     if (decode->rep) {
 545         string_rep(env, decode, exec_ins_single, 0);
 546     } else {
 547         exec_ins_single(env, decode);
 548     }
 549
 550     RIP(env) += decode->len;
 551 }
 552
 553 static void exec_outs_single(struct CPUX86State *env, struct x86_decode *decode)
 554 {
 555     addr_t addr = decode_linear_addr(env, decode, RSI(env), REG_SEG_DS);
 556
 557     vmx_read_mem(ENV_GET_CPU(env), env->hvf_emul->mmio_buf, addr, decode->operand_size);
 558     hvf_handle_io(ENV_GET_CPU(env), DX(env), env->hvf_emul->mmio_buf, 1,
 559                   decode->operand_size, 1);
 560
 561     string_increment_reg(env, REG_RSI, decode);
 562 }
 563
 564 static void exec_outs(struct CPUX86State *env, struct x86_decode *decode)
 565 {
 566     if (decode->rep) {
 567         string_rep(env, decode, exec_outs_single, 0);
 568     } else {
 569         exec_outs_single(env, decode);
 570     }
 571
 572     RIP(env) += decode->len;
 573 }
 574
 575 static void exec_movs_single(struct CPUX86State *env, struct x86_decode *decode)
 576 {
 577     addr_t src_addr;
 578     addr_t dst_addr;
 579     addr_t val;
 580
 581     src_addr = decode_linear_addr(env, decode, RSI(env), REG_SEG_DS);
 582     dst_addr = linear_addr_size(ENV_GET_CPU(env), RDI(env), decode->addressing_size,
 583                                 REG_SEG_ES);
 584
 585     val = read_val_ext(env, src_addr, decode->operand_size);
 586     write_val_ext(env, dst_addr, val, decode->operand_size);
 587
 588     string_increment_reg(env, REG_RSI, decode);
 589     string_increment_reg(env, REG_RDI, decode);
 590 }
 591
 592 static void exec_movs(struct CPUX86State *env, struct x86_decode *decode)
 593 {
 594     if (decode->rep) {
 595         string_rep(env, decode, exec_movs_single, 0);
 596     } else {
 597         exec_movs_single(env, decode);
 598     }
 599
 600     RIP(env) += decode->len;
 601 }
 602
 603 static void exec_cmps_single(struct CPUX86State *env, struct x86_decode *decode)
 604 {
 605     addr_t src_addr;
 606     addr_t dst_addr;
 607
 608     src_addr = decode_linear_addr(env, decode, RSI(env), REG_SEG_DS);
 609     dst_addr = linear_addr_size(ENV_GET_CPU(env), RDI(env), decode->addressing_size,
 610                                 REG_SEG_ES);
 611
 612     decode->op[0].type = X86_VAR_IMMEDIATE;
 613     decode->op[0].val = read_val_ext(env, src_addr, decode->operand_size);
 614     decode->op[1].type = X86_VAR_IMMEDIATE;
 615     decode->op[1].val = read_val_ext(env, dst_addr, decode->operand_size);
 616
 617     EXEC_2OP_ARITH_CMD(env, decode, -, SET_FLAGS_OSZAPC_SUB, false);
 618
 619     string_increment_reg(env, REG_RSI, decode);
 620     string_increment_reg(env, REG_RDI, decode);
 621 }
 622
 623 static void exec_cmps(struct CPUX86State *env, struct x86_decode *decode)
 624 {
 625     if (decode->rep) {
 626         string_rep(env, decode, exec_cmps_single, decode->rep);
 627     } else {
 628         exec_cmps_single(env, decode);
 629     }
 630     RIP(env) += decode->len;
 631 }
 632
 633
 634 static void exec_stos_single(struct CPUX86State *env, struct x86_decode *decode)
 635 {
 636     addr_t addr;
 637     addr_t val;
 638
 639     addr = linear_addr_size(ENV_GET_CPU(env), RDI(env), decode->addressing_size, REG_SEG_ES);
 640     val = read_reg(env, REG_RAX, decode->operand_size);
 641     vmx_write_mem(ENV_GET_CPU(env), addr, &val, decode->operand_size);
 642
 643     string_increment_reg(env, REG_RDI, decode);
 644 }
 645
 646
 647 static void exec_stos(struct CPUX86State *env, struct x86_decode *decode)
 648 {
 649     if (decode->rep) {
 650         string_rep(env, decode, exec_stos_single, 0);
 651     } else {
 652         exec_stos_single(env, decode);
 653     }
 654
 655     RIP(env) += decode->len;
 656 }
 657
 658 static void exec_scas_single(struct CPUX86State *env, struct x86_decode *decode)
 659 {
 660     addr_t addr;
 661
 662     addr = linear_addr_size(ENV_GET_CPU(env), RDI(env), decode->addressing_size, REG_SEG_ES);
 663     decode->op[1].type = X86_VAR_IMMEDIATE;
 664     vmx_read_mem(ENV_GET_CPU(env), &decode->op[1].val, addr, decode->operand_size);
 665
 666     EXEC_2OP_ARITH_CMD(env, decode, -, SET_FLAGS_OSZAPC_SUB, false);
 667     string_increment_reg(env, REG_RDI, decode);
 668 }
 669
 670 static void exec_scas(struct CPUX86State *env, struct x86_decode *decode)
 671 {
 672     decode->op[0].type = X86_VAR_REG;
 673     decode->op[0].reg = REG_RAX;
 674     if (decode->rep) {
 675         string_rep(env, decode, exec_scas_single, decode->rep);
 676     } else {
 677         exec_scas_single(env, decode);
 678     }
 679
 680     RIP(env) += decode->len;
 681 }
 682
 683 static void exec_lods_single(struct CPUX86State *env, struct x86_decode *decode)
 684 {
 685     addr_t addr;
 686     addr_t val = 0;
 687
 688     addr = decode_linear_addr(env, decode, RSI(env), REG_SEG_DS);
 689     vmx_read_mem(ENV_GET_CPU(env), &val, addr,  decode->operand_size);
 690     write_reg(env, REG_RAX, val, decode->operand_size);
 691
 692     string_increment_reg(env, REG_RSI, decode);
 693 }
 694
 695 static void exec_lods(struct CPUX86State *env, struct x86_decode *decode)
 696 {
 697     if (decode->rep) {
 698         string_rep(env, decode, exec_lods_single, 0);
 699     } else {
 700         exec_lods_single(env, decode);
 701     }
 702
 703     RIP(env) += decode->len;
 704 }
 705
 706 #define MSR_IA32_UCODE_REV 0x00000017
 707
 708 void simulate_rdmsr(struct CPUState *cpu)
 709 {
 710     X86CPU *x86_cpu = X86_CPU(cpu);
 711     CPUX86State *env = &x86_cpu->env;
 712     uint32_t msr = ECX(env);
 713     uint64_t val = 0;
 714
 715     switch (msr) {
 716     case MSR_IA32_TSC:
 717         val = rdtscp() + rvmcs(cpu->hvf_fd, VMCS_TSC_OFFSET);
 718         break;
 719     case MSR_IA32_APICBASE:
 720         val = cpu_get_apic_base(X86_CPU(cpu)->apic_state);
 721         break;
 722     case MSR_IA32_UCODE_REV:
 723         val = (0x100000000ULL << 32) | 0x100000000ULL;
 724         break;
 725     case MSR_EFER:
 726         val = rvmcs(cpu->hvf_fd, VMCS_GUEST_IA32_EFER);
 727         break;
 728     case MSR_FSBASE:
 729         val = rvmcs(cpu->hvf_fd, VMCS_GUEST_FS_BASE);
 730         break;
 731     case MSR_GSBASE:
 732         val = rvmcs(cpu->hvf_fd, VMCS_GUEST_GS_BASE);
 733         break;
 734     case MSR_KERNELGSBASE:
 735         val = rvmcs(cpu->hvf_fd, VMCS_HOST_FS_BASE);
 736         break;
 737     case MSR_STAR:
 738         abort();
 739         break;
 740     case MSR_LSTAR:
 741         abort();
 742         break;
 743     case MSR_CSTAR:
 744         abort();
 745         break;
 746     case MSR_IA32_MISC_ENABLE:
 747         val = env->msr_ia32_misc_enable;
 748         break;
 749     case MSR_MTRRphysBase(0):
 750     case MSR_MTRRphysBase(1):
 751     case MSR_MTRRphysBase(2):
 752     case MSR_MTRRphysBase(3):
 753     case MSR_MTRRphysBase(4):
 754     case MSR_MTRRphysBase(5):
 755     case MSR_MTRRphysBase(6):
 756     case MSR_MTRRphysBase(7):
 757         val = env->mtrr_var[(ECX(env) - MSR_MTRRphysBase(0)) / 2].base;
 758         break;
 759     case MSR_MTRRphysMask(0):
 760     case MSR_MTRRphysMask(1):
 761     case MSR_MTRRphysMask(2):
 762     case MSR_MTRRphysMask(3):
 763     case MSR_MTRRphysMask(4):
 764     case MSR_MTRRphysMask(5):
 765     case MSR_MTRRphysMask(6):
 766     case MSR_MTRRphysMask(7):
 767         val = env->mtrr_var[(ECX(env) - MSR_MTRRphysMask(0)) / 2].mask;
 768         break;
 769     case MSR_MTRRfix64K_00000:
 770         val = env->mtrr_fixed[0];
 771         break;
 772     case MSR_MTRRfix16K_80000:
 773     case MSR_MTRRfix16K_A0000:
 774         val = env->mtrr_fixed[ECX(env) - MSR_MTRRfix16K_80000 + 1];
 775         break;
 776     case MSR_MTRRfix4K_C0000:
 777     case MSR_MTRRfix4K_C8000:
 778     case MSR_MTRRfix4K_D0000:
 779     case MSR_MTRRfix4K_D8000:
 780     case MSR_MTRRfix4K_E0000:
 781     case MSR_MTRRfix4K_E8000:
 782     case MSR_MTRRfix4K_F0000:
 783     case MSR_MTRRfix4K_F8000:
 784         val = env->mtrr_fixed[ECX(env) - MSR_MTRRfix4K_C0000 + 3];
 785         break;
 786     case MSR_MTRRdefType:
 787         val = env->mtrr_deftype;
 788         break;
 789     default:
 790         /* fprintf(stderr, "%s: unknown msr 0x%x\n", __func__, msr); */
 791         val = 0;
 792         break;
 793     }
 794
 795     RAX(env) = (uint32_t)val;
 796     RDX(env) = (uint32_t)(val >> 32);
 797 }
 798
 799 static void exec_rdmsr(struct CPUX86State *env, struct x86_decode *decode)
 800 {
 801     simulate_rdmsr(ENV_GET_CPU(env));
 802     RIP(env) += decode->len;
 803 }
 804
 805 void simulate_wrmsr(struct CPUState *cpu)
 806 {
 807     X86CPU *x86_cpu = X86_CPU(cpu);
 808     CPUX86State *env = &x86_cpu->env;
 809     uint32_t msr = ECX(env);
 810     uint64_t data = ((uint64_t)EDX(env) << 32) | EAX(env);
 811
 812     switch (msr) {
 813     case MSR_IA32_TSC:
 814         /* if (!osx_is_sierra())
 815              wvmcs(cpu->hvf_fd, VMCS_TSC_OFFSET, data - rdtscp());
 816         hv_vm_sync_tsc(data);*/
 817         break;
 818     case MSR_IA32_APICBASE:
 819         cpu_set_apic_base(X86_CPU(cpu)->apic_state, data);
 820         break;
 821     case MSR_FSBASE:
 822         wvmcs(cpu->hvf_fd, VMCS_GUEST_FS_BASE, data);
 823         break;
 824     case MSR_GSBASE:
 825         wvmcs(cpu->hvf_fd, VMCS_GUEST_GS_BASE, data);
 826         break;
 827     case MSR_KERNELGSBASE:
 828         wvmcs(cpu->hvf_fd, VMCS_HOST_FS_BASE, data);
 829         break;
 830     case MSR_STAR:
 831         abort();
 832         break;
 833     case MSR_LSTAR:
 834         abort();
 835         break;
 836     case MSR_CSTAR:
 837         abort();
 838         break;
 839     case MSR_EFER:
 840         env->hvf_emul->efer.efer = data;
 841         /*printf("new efer %llx\n", EFER(cpu));*/
 842         wvmcs(cpu->hvf_fd, VMCS_GUEST_IA32_EFER, data);
 843         if (data & EFER_NXE) {
 844             hv_vcpu_invalidate_tlb(cpu->hvf_fd);
 845         }
 846         break;
 847     case MSR_MTRRphysBase(0):
 848     case MSR_MTRRphysBase(1):
 849     case MSR_MTRRphysBase(2):
 850     case MSR_MTRRphysBase(3):
 851     case MSR_MTRRphysBase(4):
 852     case MSR_MTRRphysBase(5):
 853     case MSR_MTRRphysBase(6):
 854     case MSR_MTRRphysBase(7):
 855         env->mtrr_var[(ECX(env) - MSR_MTRRphysBase(0)) / 2].base = data;
 856         break;
 857     case MSR_MTRRphysMask(0):
 858     case MSR_MTRRphysMask(1):
 859     case MSR_MTRRphysMask(2):
 860     case MSR_MTRRphysMask(3):
 861     case MSR_MTRRphysMask(4):
 862     case MSR_MTRRphysMask(5):
 863     case MSR_MTRRphysMask(6):
 864     case MSR_MTRRphysMask(7):
 865         env->mtrr_var[(ECX(env) - MSR_MTRRphysMask(0)) / 2].mask = data;
 866         break;
 867     case MSR_MTRRfix64K_00000:
 868         env->mtrr_fixed[ECX(env) - MSR_MTRRfix64K_00000] = data;
 869         break;
 870     case MSR_MTRRfix16K_80000:
 871     case MSR_MTRRfix16K_A0000:
 872         env->mtrr_fixed[ECX(env) - MSR_MTRRfix16K_80000 + 1] = data;
 873         break;
 874     case MSR_MTRRfix4K_C0000:
 875     case MSR_MTRRfix4K_C8000:
 876     case MSR_MTRRfix4K_D0000:
 877     case MSR_MTRRfix4K_D8000:
 878     case MSR_MTRRfix4K_E0000:
 879     case MSR_MTRRfix4K_E8000:
 880     case MSR_MTRRfix4K_F0000:
 881     case MSR_MTRRfix4K_F8000:
 882         env->mtrr_fixed[ECX(env) - MSR_MTRRfix4K_C0000 + 3] = data;
 883         break;
 884     case MSR_MTRRdefType:
 885         env->mtrr_deftype = data;
 886         break;
 887     default:
 888         break;
 889     }
 890
 891     /* Related to support known hypervisor interface */
 892     /* if (g_hypervisor_iface)
 893          g_hypervisor_iface->wrmsr_handler(cpu, msr, data);
 894
 895     printf("write msr %llx\n", RCX(cpu));*/
 896 }
 897
 898 static void exec_wrmsr(struct CPUX86State *env, struct x86_decode *decode)
 899 {
 900     simulate_wrmsr(ENV_GET_CPU(env));
 901     RIP(env) += decode->len;
 902 }
 903
 904 /*
 905  * flag:
 906  * 0 - bt, 1 - btc, 2 - bts, 3 - btr
 907  */
 908 static void do_bt(struct CPUX86State *env, struct x86_decode *decode, int flag)
 909 {
 910     int32_t displacement;
 911     uint8_t index;
 912     bool cf;
 913     int mask = (4 == decode->operand_size) ? 0x1f : 0xf;
 914
 915     VM_PANIC_ON(decode->rex.rex);
 916
 917     fetch_operands(env, decode, 2, false, true, false);
 918     index = decode->op[1].val & mask;
 919
 920     if (decode->op[0].type != X86_VAR_REG) {
 921         if (4 == decode->operand_size) {
 922             displacement = ((int32_t) (decode->op[1].val & 0xffffffe0)) / 32;
 923             decode->op[0].ptr += 4 * displacement;
 924         } else if (2 == decode->operand_size) {
 925             displacement = ((int16_t) (decode->op[1].val & 0xfff0)) / 16;
 926             decode->op[0].ptr += 2 * displacement;
 927         } else {
 928             VM_PANIC("bt 64bit\n");
 929         }
 930     }
 931     decode->op[0].val = read_val_ext(env, decode->op[0].ptr,
 932                                      decode->operand_size);
 933     cf = (decode->op[0].val >> index) & 0x01;
 934
 935     switch (flag) {
 936     case 0:
 937         set_CF(env, cf);
 938         return;
 939     case 1:
 940         decode->op[0].val ^= (1u << index);
 941         break;
 942     case 2:
 943         decode->op[0].val |= (1u << index);
 944         break;
 945     case 3:
 946         decode->op[0].val &= ~(1u << index);
 947         break;
 948     }
 949     write_val_ext(env, decode->op[0].ptr, decode->op[0].val,
 950                   decode->operand_size);
 951     set_CF(env, cf);
 952 }
 953
 954 static void exec_bt(struct CPUX86State *env, struct x86_decode *decode)
 955 {
 956     do_bt(env, decode, 0);
 957     RIP(env) += decode->len;
 958 }
 959
 960 static void exec_btc(struct CPUX86State *env, struct x86_decode *decode)
 961 {
 962     do_bt(env, decode, 1);
 963     RIP(env) += decode->len;
 964 }
 965
 966 static void exec_btr(struct CPUX86State *env, struct x86_decode *decode)
 967 {
 968     do_bt(env, decode, 3);
 969     RIP(env) += decode->len;
 970 }
 971
 972 static void exec_bts(struct CPUX86State *env, struct x86_decode *decode)
 973 {
 974     do_bt(env, decode, 2);
 975     RIP(env) += decode->len;
 976 }
 977
 978 void exec_shl(struct CPUX86State *env, struct x86_decode *decode)
 979 {
 980     uint8_t count;
 981     int of = 0, cf = 0;
 982
 983     fetch_operands(env, decode, 2, true, true, false);
 984
 985     count = decode->op[1].val;
 986     count &= 0x1f;      /* count is masked to 5 bits*/
 987     if (!count) {
 988         goto exit;
 989     }
 990
 991     switch (decode->operand_size) {
 992     case 1:
 993     {
 994         uint8_t res = 0;
 995         if (count <= 8) {
 996             res = (decode->op[0].val << count);
 997             cf = (decode->op[0].val >> (8 - count)) & 0x1;
 998             of = cf ^ (res >> 7);
 999         }
1000
1001         write_val_ext(env, decode->op[0].ptr, res, 1);
1002         SET_FLAGS_OSZAPC_LOGIC_8(res);
1003         SET_FLAGS_OxxxxC(env, of, cf);
1004         break;
1005     }
1006     case 2:
1007     {
1008         uint16_t res = 0;
1009
1010         /* from bochs */
1011         if (count <= 16) {
1012             res = (decode->op[0].val << count);
1013             cf = (decode->op[0].val >> (16 - count)) & 0x1;
1014             of = cf ^ (res >> 15); /* of = cf ^ result15 */
1015         }
1016
1017         write_val_ext(env, decode->op[0].ptr, res, 2);
1018         SET_FLAGS_OSZAPC_LOGIC_16(res);
1019         SET_FLAGS_OxxxxC(env, of, cf);
1020         break;
1021     }
1022     case 4:
1023     {
1024         uint32_t res = decode->op[0].val << count;
1025
1026         write_val_ext(env, decode->op[0].ptr, res, 4);
1027         SET_FLAGS_OSZAPC_LOGIC_32(res);
1028         cf = (decode->op[0].val >> (32 - count)) & 0x1;
1029         of = cf ^ (res >> 31); /* of = cf ^ result31 */
1030         SET_FLAGS_OxxxxC(env, of, cf);
1031         break;
1032     }
1033     default:
1034         abort();
1035     }
1036
1037 exit:
1038     /* lflags_to_rflags(env); */
1039     RIP(env) += decode->len;
1040 }
1041
1042 void exec_movsx(CPUX86State *env, struct x86_decode *decode)
1043 {
1044     int src_op_size;
1045     int op_size = decode->operand_size;
1046
1047     fetch_operands(env, decode, 2, false, false, false);
1048
1049     if (0xbe == decode->opcode[1]) {
1050         src_op_size = 1;
1051     } else {
1052         src_op_size = 2;
1053     }
1054
1055     decode->operand_size = src_op_size;
1056     calc_modrm_operand(env, decode, &decode->op[1]);
1057     decode->op[1].val = sign(read_val_ext(env, decode->op[1].ptr, src_op_size),
1058                              src_op_size);
1059
1060     write_val_ext(env, decode->op[0].ptr, decode->op[1].val, op_size);
1061
1062     RIP(env) += decode->len;
1063 }
1064
1065 void exec_ror(struct CPUX86State *env, struct x86_decode *decode)
1066 {
1067     uint8_t count;
1068
1069     fetch_operands(env, decode, 2, true, true, false);
1070     count = decode->op[1].val;
1071
1072     switch (decode->operand_size) {
1073     case 1:
1074     {
1075         uint32_t bit6, bit7;
1076         uint8_t res;
1077
1078         if ((count & 0x07) == 0) {
1079             if (count & 0x18) {
1080                 bit6 = ((uint8_t)decode->op[0].val >> 6) & 1;
1081                 bit7 = ((uint8_t)decode->op[0].val >> 7) & 1;
1082                 SET_FLAGS_OxxxxC(env, bit6 ^ bit7, bit7);
1083              }
1084         } else {
1085             count &= 0x7; /* use only bottom 3 bits */
1086             res = ((uint8_t)decode->op[0].val >> count) |
1087                    ((uint8_t)decode->op[0].val << (8 - count));
1088             write_val_ext(env, decode->op[0].ptr, res, 1);
1089             bit6 = (res >> 6) & 1;
1090             bit7 = (res >> 7) & 1;
1091             /* set eflags: ROR count affects the following flags: C, O */
1092             SET_FLAGS_OxxxxC(env, bit6 ^ bit7, bit7);
1093         }
1094         break;
1095     }
1096     case 2:
1097     {
1098         uint32_t bit14, bit15;
1099         uint16_t res;
1100
1101         if ((count & 0x0f) == 0) {
1102             if (count & 0x10) {
1103                 bit14 = ((uint16_t)decode->op[0].val >> 14) & 1;
1104                 bit15 = ((uint16_t)decode->op[0].val >> 15) & 1;
1105                 /* of = result14 ^ result15 */
1106                 SET_FLAGS_OxxxxC(env, bit14 ^ bit15, bit15);
1107             }
1108         } else {
1109             count &= 0x0f;  /* use only 4 LSB's */
1110             res = ((uint16_t)decode->op[0].val >> count) |
1111                    ((uint16_t)decode->op[0].val << (16 - count));
1112             write_val_ext(env, decode->op[0].ptr, res, 2);
1113
1114             bit14 = (res >> 14) & 1;
1115             bit15 = (res >> 15) & 1;
1116             /* of = result14 ^ result15 */
1117             SET_FLAGS_OxxxxC(env, bit14 ^ bit15, bit15);
1118         }
1119         break;
1120     }
1121     case 4:
1122     {
1123         uint32_t bit31, bit30;
1124         uint32_t res;
1125
1126         count &= 0x1f;
1127         if (count) {
1128             res = ((uint32_t)decode->op[0].val >> count) |
1129                    ((uint32_t)decode->op[0].val << (32 - count));
1130             write_val_ext(env, decode->op[0].ptr, res, 4);
1131
1132             bit31 = (res >> 31) & 1;
1133             bit30 = (res >> 30) & 1;
1134             /* of = result30 ^ result31 */
1135             SET_FLAGS_OxxxxC(env, bit30 ^ bit31, bit31);
1136         }
1137         break;
1138         }
1139     }
1140     RIP(env) += decode->len;
1141 }
1142
1143 void exec_rol(struct CPUX86State *env, struct x86_decode *decode)
1144 {
1145     uint8_t count;
1146
1147     fetch_operands(env, decode, 2, true, true, false);
1148     count = decode->op[1].val;
1149
1150     switch (decode->operand_size) {
1151     case 1:
1152     {
1153         uint32_t bit0, bit7;
1154         uint8_t res;
1155
1156         if ((count & 0x07) == 0) {
1157             if (count & 0x18) {
1158                 bit0 = ((uint8_t)decode->op[0].val & 1);
1159                 bit7 = ((uint8_t)decode->op[0].val >> 7);
1160                 SET_FLAGS_OxxxxC(env, bit0 ^ bit7, bit0);
1161             }
1162         }  else {
1163             count &= 0x7; /* use only lowest 3 bits */
1164             res = ((uint8_t)decode->op[0].val << count) |
1165                    ((uint8_t)decode->op[0].val >> (8 - count));
1166
1167             write_val_ext(env, decode->op[0].ptr, res, 1);
1168             /* set eflags:
1169              * ROL count affects the following flags: C, O
1170              */
1171             bit0 = (res &  1);
1172             bit7 = (res >> 7);
1173             SET_FLAGS_OxxxxC(env, bit0 ^ bit7, bit0);
1174         }
1175         break;
1176     }
1177     case 2:
1178     {
1179         uint32_t bit0, bit15;
1180         uint16_t res;
1181
1182         if ((count & 0x0f) == 0) {
1183             if (count & 0x10) {
1184                 bit0  = ((uint16_t)decode->op[0].val & 0x1);
1185                 bit15 = ((uint16_t)decode->op[0].val >> 15);
1186                 /* of = cf ^ result15 */
1187                 SET_FLAGS_OxxxxC(env, bit0 ^ bit15, bit0);
1188             }
1189         } else {
1190             count &= 0x0f; /* only use bottom 4 bits */
1191             res = ((uint16_t)decode->op[0].val << count) |
1192                    ((uint16_t)decode->op[0].val >> (16 - count));
1193
1194             write_val_ext(env, decode->op[0].ptr, res, 2);
1195             bit0  = (res & 0x1);
1196             bit15 = (res >> 15);
1197             /* of = cf ^ result15 */
1198             SET_FLAGS_OxxxxC(env, bit0 ^ bit15, bit0);
1199         }
1200         break;
1201     }
1202     case 4:
1203     {
1204         uint32_t bit0, bit31;
1205         uint32_t res;
1206
1207         count &= 0x1f;
1208         if (count) {
1209             res = ((uint32_t)decode->op[0].val << count) |
1210                    ((uint32_t)decode->op[0].val >> (32 - count));
1211
1212             write_val_ext(env, decode->op[0].ptr, res, 4);
1213             bit0  = (res & 0x1);
1214             bit31 = (res >> 31);
1215             /* of = cf ^ result31 */
1216             SET_FLAGS_OxxxxC(env, bit0 ^ bit31, bit0);
1217         }
1218         break;
1219         }
1220     }
1221     RIP(env) += decode->len;
1222 }
1223
1224
1225 void exec_rcl(struct CPUX86State *env, struct x86_decode *decode)
1226 {
1227     uint8_t count;
1228     int of = 0, cf = 0;
1229
1230     fetch_operands(env, decode, 2, true, true, false);
1231     count = decode->op[1].val & 0x1f;
1232
1233     switch (decode->operand_size) {
1234     case 1:
1235     {
1236         uint8_t op1_8 = decode->op[0].val;
1237         uint8_t res;
1238         count %= 9;
1239         if (!count) {
1240             break;
1241         }
1242
1243         if (1 == count) {
1244             res = (op1_8 << 1) | get_CF(env);
1245         } else {
1246             res = (op1_8 << count) | (get_CF(env) << (count - 1)) |
1247                    (op1_8 >> (9 - count));
1248         }
1249
1250         write_val_ext(env, decode->op[0].ptr, res, 1);
1251
1252         cf = (op1_8 >> (8 - count)) & 0x01;
1253         of = cf ^ (res >> 7); /* of = cf ^ result7 */
1254         SET_FLAGS_OxxxxC(env, of, cf);
1255         break;
1256     }
1257     case 2:
1258     {
1259         uint16_t res;
1260         uint16_t op1_16 = decode->op[0].val;
1261
1262         count %= 17;
1263         if (!count) {
1264             break;
1265         }
1266
1267         if (1 == count) {
1268             res = (op1_16 << 1) | get_CF(env);
1269         } else if (count == 16) {
1270             res = (get_CF(env) << 15) | (op1_16 >> 1);
1271         } else { /* 2..15 */
1272             res = (op1_16 << count) | (get_CF(env) << (count - 1)) |
1273                    (op1_16 >> (17 - count));
1274         }
1275
1276         write_val_ext(env, decode->op[0].ptr, res, 2);
1277
1278         cf = (op1_16 >> (16 - count)) & 0x1;
1279         of = cf ^ (res >> 15); /* of = cf ^ result15 */
1280         SET_FLAGS_OxxxxC(env, of, cf);
1281         break;
1282     }
1283     case 4:
1284     {
1285         uint32_t res;
1286         uint32_t op1_32 = decode->op[0].val;
1287
1288         if (!count) {
1289             break;
1290         }
1291
1292         if (1 == count) {
1293             res = (op1_32 << 1) | get_CF(env);
1294         } else {
1295             res = (op1_32 << count) | (get_CF(env) << (count - 1)) |
1296                    (op1_32 >> (33 - count));
1297         }
1298
1299         write_val_ext(env, decode->op[0].ptr, res, 4);
1300
1301         cf = (op1_32 >> (32 - count)) & 0x1;
1302         of = cf ^ (res >> 31); /* of = cf ^ result31 */
1303         SET_FLAGS_OxxxxC(env, of, cf);
1304         break;
1305         }
1306     }
1307     RIP(env) += decode->len;
1308 }
1309
1310 void exec_rcr(struct CPUX86State *env, struct x86_decode *decode)
1311 {
1312     uint8_t count;
1313     int of = 0, cf = 0;
1314
1315     fetch_operands(env, decode, 2, true, true, false);
1316     count = decode->op[1].val & 0x1f;
1317
1318     switch (decode->operand_size) {
1319     case 1:
1320     {
1321         uint8_t op1_8 = decode->op[0].val;
1322         uint8_t res;
1323
1324         count %= 9;
1325         if (!count) {
1326             break;
1327         }
1328         res = (op1_8 >> count) | (get_CF(env) << (8 - count)) |
1329                (op1_8 << (9 - count));
1330
1331         write_val_ext(env, decode->op[0].ptr, res, 1);
1332
1333         cf = (op1_8 >> (count - 1)) & 0x1;
1334         of = (((res << 1) ^ res) >> 7) & 0x1; /* of = result6 ^ result7 */
1335         SET_FLAGS_OxxxxC(env, of, cf);
1336         break;
1337     }
1338     case 2:
1339     {
1340         uint16_t op1_16 = decode->op[0].val;
1341         uint16_t res;
1342
1343         count %= 17;
1344         if (!count) {
1345             break;
1346         }
1347         res = (op1_16 >> count) | (get_CF(env) << (16 - count)) |
1348                (op1_16 << (17 - count));
1349
1350         write_val_ext(env, decode->op[0].ptr, res, 2);
1351
1352         cf = (op1_16 >> (count - 1)) & 0x1;
1353         of = ((uint16_t)((res << 1) ^ res) >> 15) & 0x1; /* of = result15 ^
1354                                                             result14 */
1355         SET_FLAGS_OxxxxC(env, of, cf);
1356         break;
1357     }
1358     case 4:
1359     {
1360         uint32_t res;
1361         uint32_t op1_32 = decode->op[0].val;
1362
1363         if (!count) {
1364             break;
1365         }
1366
1367         if (1 == count) {
1368             res = (op1_32 >> 1) | (get_CF(env) << 31);
1369         } else {
1370             res = (op1_32 >> count) | (get_CF(env) << (32 - count)) |
1371                    (op1_32 << (33 - count));
1372         }
1373
1374         write_val_ext(env, decode->op[0].ptr, res, 4);
1375
1376         cf = (op1_32 >> (count - 1)) & 0x1;
1377         of = ((res << 1) ^ res) >> 31; /* of = result30 ^ result31 */
1378         SET_FLAGS_OxxxxC(env, of, cf);
1379         break;
1380         }
1381     }
1382     RIP(env) += decode->len;
1383 }
1384
1385 static void exec_xchg(struct CPUX86State *env, struct x86_decode *decode)
1386 {
1387     fetch_operands(env, decode, 2, true, true, false);
1388
1389     write_val_ext(env, decode->op[0].ptr, decode->op[1].val,
1390                   decode->operand_size);
1391     write_val_ext(env, decode->op[1].ptr, decode->op[0].val,
1392                   decode->operand_size);
1393
1394     RIP(env) += decode->len;
1395 }
1396
1397 static void exec_xadd(struct CPUX86State *env, struct x86_decode *decode)
1398 {
1399     EXEC_2OP_ARITH_CMD(env, decode, +, SET_FLAGS_OSZAPC_ADD, true);
1400     write_val_ext(env, decode->op[1].ptr, decode->op[0].val,
1401                   decode->operand_size);
1402
1403     RIP(env) += decode->len;
1404 }
1405
1406 static struct cmd_handler {
1407     enum x86_decode_cmd cmd;
1408     void (*handler)(struct CPUX86State *env, struct x86_decode *ins);
1409 } handlers[] = {
1410     {X86_DECODE_CMD_INVL, NULL,},
1411     {X86_DECODE_CMD_MOV, exec_mov},
1412     {X86_DECODE_CMD_ADD, exec_add},
1413     {X86_DECODE_CMD_OR, exec_or},
1414     {X86_DECODE_CMD_ADC, exec_adc},
1415     {X86_DECODE_CMD_SBB, exec_sbb},
1416     {X86_DECODE_CMD_AND, exec_and},
1417     {X86_DECODE_CMD_SUB, exec_sub},
1418     {X86_DECODE_CMD_NEG, exec_neg},
1419     {X86_DECODE_CMD_XOR, exec_xor},
1420     {X86_DECODE_CMD_CMP, exec_cmp},
1421     {X86_DECODE_CMD_INC, exec_inc},
1422     {X86_DECODE_CMD_DEC, exec_dec},
1423     {X86_DECODE_CMD_TST, exec_tst},
1424     {X86_DECODE_CMD_NOT, exec_not},
1425     {X86_DECODE_CMD_MOVZX, exec_movzx},
1426     {X86_DECODE_CMD_OUT, exec_out},
1427     {X86_DECODE_CMD_IN, exec_in},
1428     {X86_DECODE_CMD_INS, exec_ins},
1429     {X86_DECODE_CMD_OUTS, exec_outs},
1430     {X86_DECODE_CMD_RDMSR, exec_rdmsr},
1431     {X86_DECODE_CMD_WRMSR, exec_wrmsr},
1432     {X86_DECODE_CMD_BT, exec_bt},
1433     {X86_DECODE_CMD_BTR, exec_btr},
1434     {X86_DECODE_CMD_BTC, exec_btc},
1435     {X86_DECODE_CMD_BTS, exec_bts},
1436     {X86_DECODE_CMD_SHL, exec_shl},
1437     {X86_DECODE_CMD_ROL, exec_rol},
1438     {X86_DECODE_CMD_ROR, exec_ror},
1439     {X86_DECODE_CMD_RCR, exec_rcr},
1440     {X86_DECODE_CMD_RCL, exec_rcl},
1441     /*{X86_DECODE_CMD_CPUID, exec_cpuid},*/
1442     {X86_DECODE_CMD_MOVS, exec_movs},
1443     {X86_DECODE_CMD_CMPS, exec_cmps},
1444     {X86_DECODE_CMD_STOS, exec_stos},
1445     {X86_DECODE_CMD_SCAS, exec_scas},
1446     {X86_DECODE_CMD_LODS, exec_lods},
1447     {X86_DECODE_CMD_MOVSX, exec_movsx},
1448     {X86_DECODE_CMD_XCHG, exec_xchg},
1449     {X86_DECODE_CMD_XADD, exec_xadd},
1450 };
1451
1452 static struct cmd_handler _cmd_handler[X86_DECODE_CMD_LAST];
1453
1454 static void init_cmd_handler()
1455 {
1456     int i;
1457     for (i = 0; i < ARRAY_SIZE(handlers); i++) {
1458         _cmd_handler[handlers[i].cmd] = handlers[i];
1459     }
1460 }
1461
1462 void load_regs(struct CPUState *cpu)
1463 {
1464     X86CPU *x86_cpu = X86_CPU(cpu);
1465     CPUX86State *env = &x86_cpu->env;
1466
1467     int i = 0;
1468     RRX(env, REG_RAX) = rreg(cpu->hvf_fd, HV_X86_RAX);
1469     RRX(env, REG_RBX) = rreg(cpu->hvf_fd, HV_X86_RBX);
1470     RRX(env, REG_RCX) = rreg(cpu->hvf_fd, HV_X86_RCX);
1471     RRX(env, REG_RDX) = rreg(cpu->hvf_fd, HV_X86_RDX);
1472     RRX(env, REG_RSI) = rreg(cpu->hvf_fd, HV_X86_RSI);
1473     RRX(env, REG_RDI) = rreg(cpu->hvf_fd, HV_X86_RDI);
1474     RRX(env, REG_RSP) = rreg(cpu->hvf_fd, HV_X86_RSP);
1475     RRX(env, REG_RBP) = rreg(cpu->hvf_fd, HV_X86_RBP);
1476     for (i = 8; i < 16; i++) {
1477         RRX(env, i) = rreg(cpu->hvf_fd, HV_X86_RAX + i);
1478     }
1479
1480     RFLAGS(env) = rreg(cpu->hvf_fd, HV_X86_RFLAGS);
1481     rflags_to_lflags(env);
1482     RIP(env) = rreg(cpu->hvf_fd, HV_X86_RIP);
1483 }
1484
1485 void store_regs(struct CPUState *cpu)
1486 {
1487     X86CPU *x86_cpu = X86_CPU(cpu);
1488     CPUX86State *env = &x86_cpu->env;
1489
1490     int i = 0;
1491     wreg(cpu->hvf_fd, HV_X86_RAX, RAX(env));
1492     wreg(cpu->hvf_fd, HV_X86_RBX, RBX(env));
1493     wreg(cpu->hvf_fd, HV_X86_RCX, RCX(env));
1494     wreg(cpu->hvf_fd, HV_X86_RDX, RDX(env));
1495     wreg(cpu->hvf_fd, HV_X86_RSI, RSI(env));
1496     wreg(cpu->hvf_fd, HV_X86_RDI, RDI(env));
1497     wreg(cpu->hvf_fd, HV_X86_RBP, RBP(env));
1498     wreg(cpu->hvf_fd, HV_X86_RSP, RSP(env));
1499     for (i = 8; i < 16; i++) {
1500         wreg(cpu->hvf_fd, HV_X86_RAX + i, RRX(env, i));
1501     }
1502
1503     lflags_to_rflags(env);
1504     wreg(cpu->hvf_fd, HV_X86_RFLAGS, RFLAGS(env));
1505     macvm_set_rip(cpu, RIP(env));
1506 }
1507
1508 bool exec_instruction(struct CPUX86State *env, struct x86_decode *ins)
1509 {
1510     /*if (hvf_vcpu_id(cpu))
1511     printf("%d, %llx: exec_instruction %s\n", hvf_vcpu_id(cpu),  RIP(cpu),
1512           decode_cmd_to_string(ins->cmd));*/
1513
1514     if (0 && ins->is_fpu) {
1515         VM_PANIC("emulate fpu\n");
1516     } else {
1517         if (!_cmd_handler[ins->cmd].handler) {
1518             printf("Unimplemented handler (%llx) for %d (%x %x) \n", RIP(env),
1519                     ins->cmd, ins->opcode[0],
1520                     ins->opcode_len > 1 ? ins->opcode[1] : 0);
1521             RIP(env) += ins->len;
1522             return true;
1523         }
1524
1525         VM_PANIC_ON_EX(!_cmd_handler[ins->cmd].handler,
1526                 "Unimplemented handler (%llx) for %d (%x %x) \n", RIP(env),
1527                  ins->cmd, ins->opcode[0],
1528                  ins->opcode_len > 1 ? ins->opcode[1] : 0);
1529         _cmd_handler[ins->cmd].handler(env, ins);
1530     }
1531     return true;
1532 }
1533
1534 void init_emu()
1535 {
1536     init_cmd_handler();
1537 }