Lines Matching defs:vie
215 /* struct vie.mod */
221 /* struct vie.rm */
264 vie_calc_bytereg(struct vie *vie, enum vm_reg_name *reg, int *lhbr)
267 *reg = gpr_map[vie->reg];
281 if (!vie->rex_present) {
282 if (vie->reg & 0x4) {
284 *reg = gpr_map[vie->reg & 0x3];
290 vie_read_bytereg(void *vm, int vcpuid, struct vie *vie, uint8_t *rval)
296 vie_calc_bytereg(vie, ®, &lhbr);
311 vie_write_bytereg(void *vm, int vcpuid, struct vie *vie, uint8_t byte)
317 vie_calc_bytereg(vie, ®, &lhbr);
403 emulate_mov(void *vm, int vcpuid, uint64_t gpa, struct vie *vie,
411 size = vie->opsize;
414 switch (vie->op.op_byte) {
422 error = vie_read_bytereg(vm, vcpuid, vie, &byte);
433 reg = gpr_map[vie->reg];
449 error = vie_write_bytereg(vm, vcpuid, vie, val);
460 reg = gpr_map[vie->reg];
497 error = memwrite(vm, vcpuid, gpa, vie->immediate, size, arg);
506 val = vie->immediate & size2mask[size];
517 emulate_movx(void *vm, int vcpuid, uint64_t gpa, struct vie *vie,
525 size = vie->opsize;
528 switch (vie->op.op_byte) {
545 reg = gpr_map[vie->reg];
565 reg = gpr_map[vie->reg];
588 reg = gpr_map[vie->reg];
606 get_gla(void *vm, int vcpuid, struct vie *vie, struct vm_guest_paging *paging,
659 emulate_movs(void *vm, int vcpuid, uint64_t gpa, struct vie *vie,
672 opsize = (vie->op.op_byte == 0xA4) ? 1 : vie->opsize;
683 repeat = vie->repz_present | vie->repnz_present;
693 if ((rcx & vie_size2mask(vie->addrsize)) == 0) {
715 seg = vie->segment_override ? vie->segment_register : VM_REG_GUEST_DS;
716 error = get_gla(vm, vcpuid, vie, paging, opsize, vie->addrsize,
741 error = get_gla(vm, vcpuid, vie, paging, opsize, vie->addrsize,
815 vie->addrsize);
819 vie->addrsize);
825 rcx, vie->addrsize);
831 if ((rcx & vie_size2mask(vie->addrsize)) != 0)
841 emulate_stos(void *vm, int vcpuid, uint64_t gpa, struct vie *vie,
849 opsize = (vie->op.op_byte == 0xAA) ? 1 : vie->opsize;
850 repeat = vie->repz_present | vie->repnz_present;
860 if ((rcx & vie_size2mask(vie->addrsize)) == 0)
883 vie->addrsize);
889 rcx, vie->addrsize);
895 if ((rcx & vie_size2mask(vie->addrsize)) != 0)
903 emulate_and(void *vm, int vcpuid, uint64_t gpa, struct vie *vie,
910 size = vie->opsize;
913 switch (vie->op.op_byte) {
925 reg = gpr_map[vie->reg];
963 result = val1 & vie->immediate;
991 emulate_or(void *vm, int vcpuid, uint64_t gpa, struct vie *vie,
997 size = vie->opsize;
1000 switch (vie->op.op_byte) {
1025 result = val1 | vie->immediate;
1053 emulate_cmp(void *vm, int vcpuid, uint64_t gpa, struct vie *vie,
1060 size = vie->opsize;
1061 switch (vie->op.op_byte) {
1080 reg = gpr_map[vie->reg];
1090 if (vie->op.op_byte == 0x3B) {
1121 if (vie->op.op_byte == 0x80)
1129 rflags2 = getcc(size, op1, vie->immediate);
1145 emulate_sub(void *vm, int vcpuid, uint64_t gpa, struct vie *vie,
1152 size = vie->opsize;
1155 switch (vie->op.op_byte) {
1166 reg = gpr_map[vie->reg];
1201 emulate_stack_op(void *vm, int vcpuid, uint64_t mmio_gpa, struct vie *vie,
1215 size = vie->opsize;
1216 pushop = (vie->op.op_type == VIE_OP_TYPE_PUSH) ? 1 : 0;
1232 size = vie->opsize_override ? 2 : 8;
1303 emulate_push(void *vm, int vcpuid, uint64_t mmio_gpa, struct vie *vie,
1315 if ((vie->reg & 7) != 6)
1318 error = emulate_stack_op(vm, vcpuid, mmio_gpa, vie, paging, memread,
1324 emulate_pop(void *vm, int vcpuid, uint64_t mmio_gpa, struct vie *vie,
1336 if ((vie->reg & 7) != 0)
1339 error = emulate_stack_op(vm, vcpuid, mmio_gpa, vie, paging, memread,
1345 emulate_group1(void *vm, int vcpuid, uint64_t gpa, struct vie *vie,
1351 switch (vie->reg & 7) {
1353 error = emulate_or(vm, vcpuid, gpa, vie,
1357 error = emulate_and(vm, vcpuid, gpa, vie,
1361 error = emulate_cmp(vm, vcpuid, gpa, vie,
1373 emulate_bittest(void *vm, int vcpuid, uint64_t gpa, struct vie *vie,
1385 if ((vie->reg & 7) != 4)
1391 error = memread(vm, vcpuid, gpa, &val, vie->opsize, memarg);
1399 bitmask = vie->opsize * 8 - 1;
1400 bitoff = vie->immediate & bitmask;
1415 vmm_emulate_instruction(void *vm, int vcpuid, uint64_t gpa, struct vie *vie,
1421 if (!vie->decoded)
1424 switch (vie->op.op_type) {
1426 error = emulate_group1(vm, vcpuid, gpa, vie, paging, memread,
1430 error = emulate_pop(vm, vcpuid, gpa, vie, paging, memread,
1434 error = emulate_push(vm, vcpuid, gpa, vie, paging, memread,
1438 error = emulate_cmp(vm, vcpuid, gpa, vie,
1442 error = emulate_mov(vm, vcpuid, gpa, vie,
1447 error = emulate_movx(vm, vcpuid, gpa, vie,
1451 error = emulate_movs(vm, vcpuid, gpa, vie, paging, memread,
1455 error = emulate_stos(vm, vcpuid, gpa, vie, paging, memread,
1459 error = emulate_and(vm, vcpuid, gpa, vie,
1463 error = emulate_or(vm, vcpuid, gpa, vie,
1467 error = emulate_sub(vm, vcpuid, gpa, vie,
1471 error = emulate_bittest(vm, vcpuid, gpa, vie,
1634 vie_init(struct vie *vie, const char *inst_bytes, int inst_length)
1639 bzero(vie, sizeof(struct vie));
1641 vie->base_register = VM_REG_LAST;
1642 vie->index_register = VM_REG_LAST;
1643 vie->segment_register = VM_REG_LAST;
1646 bcopy(inst_bytes, vie->inst, inst_length);
1647 vie->num_valid = inst_length;
1878 uint64_t rip, int inst_length, struct vie *vie, int *faultptr)
1892 vm_copyin(vm, vcpuid, copyinfo, vie->inst, inst_length);
1894 vie->num_valid = inst_length;
1899 vie_peek(struct vie *vie, uint8_t *x)
1902 if (vie->num_processed < vie->num_valid) {
1903 *x = vie->inst[vie->num_processed];
1910 vie_advance(struct vie *vie)
1913 vie->num_processed++;
1946 decode_prefixes(struct vie *vie, enum vm_cpu_mode cpu_mode, int cs_d)
1951 if (vie_peek(vie, &x))
1955 vie->opsize_override = 1;
1957 vie->addrsize_override = 1;
1959 vie->repz_present = 1;
1961 vie->repnz_present = 1;
1962 else if (segment_override(x, &vie->segment_register))
1963 vie->segment_override = 1;
1967 vie_advance(vie);
1979 vie->rex_present = 1;
1980 vie->rex_w = x & 0x8 ? 1 : 0;
1981 vie->rex_r = x & 0x4 ? 1 : 0;
1982 vie->rex_x = x & 0x2 ? 1 : 0;
1983 vie->rex_b = x & 0x1 ? 1 : 0;
1984 vie_advance(vie);
1995 vie->addrsize = vie->addrsize_override ? 4 : 8;
1996 if (vie->rex_w)
1997 vie->opsize = 8;
1998 else if (vie->opsize_override)
1999 vie->opsize = 2;
2001 vie->opsize = 4;
2004 vie->addrsize = vie->addrsize_override ? 2 : 4;
2005 vie->opsize = vie->opsize_override ? 2 : 4;
2008 vie->addrsize = vie->addrsize_override ? 4 : 2;
2009 vie->opsize = vie->opsize_override ? 4 : 2;
2015 decode_two_byte_opcode(struct vie *vie)
2019 if (vie_peek(vie, &x))
2022 vie->op = two_byte_opcodes[x];
2024 if (vie->op.op_type == VIE_OP_TYPE_NONE)
2027 vie_advance(vie);
2032 decode_opcode(struct vie *vie)
2036 if (vie_peek(vie, &x))
2039 vie->op = one_byte_opcodes[x];
2041 if (vie->op.op_type == VIE_OP_TYPE_NONE)
2044 vie_advance(vie);
2046 if (vie->op.op_type == VIE_OP_TYPE_TWO_BYTE)
2047 return (decode_two_byte_opcode(vie));
2053 decode_modrm(struct vie *vie, enum vm_cpu_mode cpu_mode)
2057 if (vie->op.op_flags & VIE_OP_F_NO_MODRM)
2063 if (vie_peek(vie, &x))
2066 vie->mod = (x >> 6) & 0x3;
2067 vie->rm = (x >> 0) & 0x7;
2068 vie->reg = (x >> 3) & 0x7;
2075 if (vie->mod == VIE_MOD_DIRECT)
2078 if ((vie->mod == VIE_MOD_INDIRECT && vie->rm == VIE_RM_DISP32) ||
2079 (vie->mod != VIE_MOD_DIRECT && vie->rm == VIE_RM_SIB)) {
2093 vie->rm |= (vie->rex_b << 3);
2096 vie->reg |= (vie->rex_r << 3);
2099 if (vie->mod != VIE_MOD_DIRECT && vie->rm == VIE_RM_SIB)
2102 vie->base_register = gpr_map[vie->rm];
2104 switch (vie->mod) {
2106 vie->disp_bytes = 1;
2109 vie->disp_bytes = 4;
2112 if (vie->rm == VIE_RM_DISP32) {
2113 vie->disp_bytes = 4;
2122 vie->base_register = VM_REG_GUEST_RIP;
2124 vie->base_register = VM_REG_LAST;
2130 vie_advance(vie);
2136 decode_sib(struct vie *vie)
2141 if (vie->mod == VIE_MOD_DIRECT || vie->rm != VIE_RM_SIB)
2144 if (vie_peek(vie, &x))
2148 vie->ss = (x >> 6) & 0x3;
2149 vie->index = (x >> 3) & 0x7;
2150 vie->base = (x >> 0) & 0x7;
2153 vie->index |= vie->rex_x << 3;
2154 vie->base |= vie->rex_b << 3;
2156 switch (vie->mod) {
2158 vie->disp_bytes = 1;
2161 vie->disp_bytes = 4;
2165 if (vie->mod == VIE_MOD_INDIRECT &&
2166 (vie->base == 5 || vie->base == 13)) {
2175 vie->disp_bytes = 4;
2177 vie->base_register = gpr_map[vie->base];
2187 if (vie->index != 4)
2188 vie->index_register = gpr_map[vie->index];
2191 if (vie->index_register < VM_REG_LAST)
2192 vie->scale = 1 << vie->ss;
2194 vie_advance(vie);
2200 decode_displacement(struct vie *vie)
2211 if ((n = vie->disp_bytes) == 0)
2218 if (vie_peek(vie, &x))
2222 vie_advance(vie);
2226 vie->displacement = u.signed8; /* sign-extended */
2228 vie->displacement = u.signed32; /* sign-extended */
2234 decode_immediate(struct vie *vie)
2246 if (vie->op.op_flags & VIE_OP_F_IMM) {
2254 if (vie->opsize == 4 || vie->opsize == 8)
2255 vie->imm_bytes = 4;
2257 vie->imm_bytes = 2;
2258 } else if (vie->op.op_flags & VIE_OP_F_IMM8) {
2259 vie->imm_bytes = 1;
2262 if ((n = vie->imm_bytes) == 0)
2269 if (vie_peek(vie, &x))
2273 vie_advance(vie);
2278 vie->immediate = u.signed8;
2280 vie->immediate = u.signed16;
2282 vie->immediate = u.signed32;
2288 decode_moffset(struct vie *vie)
2297 if ((vie->op.op_flags & VIE_OP_F_MOFFSET) == 0)
2304 n = vie->addrsize;
2309 if (vie_peek(vie, &x))
2313 vie_advance(vie);
2315 vie->displacement = u.u64;
2324 verify_gla(struct vm *vm, int cpuid, uint64_t gla, struct vie *vie,
2337 if (vie->base_register != VM_REG_LAST) {
2338 error = vm_get_register(vm, cpuid, vie->base_register, &base);
2341 error, vie->base_register);
2349 if (vie->base_register == VM_REG_GUEST_RIP)
2350 base += vie->num_processed;
2354 if (vie->index_register != VM_REG_LAST) {
2355 error = vm_get_register(vm, cpuid, vie->index_register, &idx);
2358 error, vie->index_register);
2376 if (vie->segment_override)
2377 seg = vie->segment_register;
2378 else if (vie->base_register == VM_REG_GUEST_RSP ||
2379 vie->base_register == VM_REG_GUEST_RBP)
2391 vie->segment_register);
2397 gla2 = segbase + base + vie->scale * idx + vie->displacement;
2398 gla2 &= size2mask[vie->addrsize];
2403 segbase, base, vie->scale, idx, vie->displacement,
2413 enum vm_cpu_mode cpu_mode, int cs_d, struct vie *vie)
2416 if (decode_prefixes(vie, cpu_mode, cs_d))
2419 if (decode_opcode(vie))
2422 if (decode_modrm(vie, cpu_mode))
2425 if (decode_sib(vie))
2428 if (decode_displacement(vie))
2431 if (decode_immediate(vie))
2434 if (decode_moffset(vie))
2437 if ((vie->op.op_flags & VIE_OP_F_NO_GLA_VERIFICATION) == 0) {
2438 if (verify_gla(vm, cpuid, gla, vie, cpu_mode))
2442 vie->decoded = 1; /* success */