mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

x86: switch to AREG0 free mode

Browse Source 
Add an explicit CPUX86State parameter instead of relying on AREG0.

Remove temporary wrappers and switch to AREG0 free mode.

Signed-off-by: Blue Swirl <blauwirbel@gmail.com>
This commit is contained in:
Blue Swirl 2012-04-29 20:35:48 +00:00
parent 2999a0b200
commit 92fc4b586f
11 changed files with 151 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
configure vendored
View File

@ -3778,7 +3778,7 @@ symlink "$source_path/Makefile.target" "$target_dir/Makefile"
case "$target_arch2" in case "$target_arch2" in
alpha | or32 | sparc* | xtensa* | ppc*) alpha | i386 | or32 | sparc* | x86_64 | xtensa* | ppc*)
echo "CONFIG_TCG_PASS_AREG0=y" >> $config_target_mak echo "CONFIG_TCG_PASS_AREG0=y" >> $config_target_mak
;; ;;
esac esac

22
cpu-all.h
View File

@ -274,6 +274,28 @@ extern unsigned long reserved_va;
#define cpu_ldsw_code(env1, p) ldsw_raw(p) #define cpu_ldsw_code(env1, p) ldsw_raw(p)
#define cpu_ldl_code(env1, p) ldl_raw(p) #define cpu_ldl_code(env1, p) ldl_raw(p)
#define cpu_ldq_code(env1, p) ldq_raw(p) #define cpu_ldq_code(env1, p) ldq_raw(p)
#define cpu_ldub_data(env, addr) ldub_raw(addr)
#define cpu_lduw_data(env, addr) lduw_raw(addr)
#define cpu_ldsw_data(env, addr) ldsw_raw(addr)
#define cpu_ldl_data(env, addr) ldl_raw(addr)
#define cpu_ldq_data(env, addr) ldq_raw(addr)
#define cpu_stb_data(env, addr, data) stb_raw(addr, data)
#define cpu_stw_data(env, addr, data) stw_raw(addr, data)
#define cpu_stl_data(env, addr, data) stl_raw(addr, data)
#define cpu_stq_data(env, addr, data) stq_raw(addr, data)
#define cpu_ldub_kernel(env, addr) ldub_raw(addr)
#define cpu_lduw_kernel(env, addr) lduw_raw(addr)
#define cpu_ldsw_kernel(env, addr) ldsw_raw(addr)
#define cpu_ldl_kernel(env, addr) ldl_raw(addr)
#define cpu_ldq_kernel(env, addr) ldq_raw(addr)
#define cpu_stb_kernel(env, addr, data) stb_raw(addr, data)
#define cpu_stw_kernel(env, addr, data) stw_raw(addr, data)
#define cpu_stl_kernel(env, addr, data) stl_raw(addr, data)
#define cpu_stq_kernel(env, addr, data) stq_raw(addr, data)
#endif #endif
#define ldub_kernel(p) ldub_raw(p) #define ldub_kernel(p) ldub_raw(p)

2
target-i386/Makefile.objs
View File

@ -6,5 +6,3 @@ obj-$(CONFIG_KVM) += kvm.o hyperv.o
obj-$(CONFIG_NO_KVM) += kvm-stub.o obj-$(CONFIG_NO_KVM) += kvm-stub.o
obj-$(CONFIG_LINUX_USER) += ioport-user.o obj-$(CONFIG_LINUX_USER) += ioport-user.o
obj-$(CONFIG_BSD_USER) += ioport-user.o obj-$(CONFIG_BSD_USER) += ioport-user.o
$(obj)/mem_helper.o: QEMU_CFLAGS += $(HELPER_CFLAGS)

21
target-i386/cpu.h
View File

@ -1138,25 +1138,4 @@ void do_smm_enter(CPUX86State *env1);
void cpu_report_tpr_access(CPUX86State *env, TPRAccess access); void cpu_report_tpr_access(CPUX86State *env, TPRAccess access);
/* temporary wrappers */
uint32_t cpu_ldub_data(CPUX86State *env, target_ulong ptr);
uint32_t cpu_lduw_data(CPUX86State *env, target_ulong ptr);
uint32_t cpu_ldl_data(CPUX86State *env, target_ulong ptr);
uint64_t cpu_ldq_data(CPUX86State *env, target_ulong ptr);
void cpu_stb_data(CPUX86State *env, target_ulong ptr, uint32_t data);
void cpu_stw_data(CPUX86State *env, target_ulong ptr, uint32_t data);
void cpu_stl_data(CPUX86State *env, target_ulong ptr, uint32_t data);
void cpu_stq_data(CPUX86State *env, target_ulong ptr, uint64_t data);
uint32_t cpu_ldub_kernel(CPUX86State *env, target_ulong ptr);
uint32_t cpu_lduw_kernel(CPUX86State *env, target_ulong ptr);
uint32_t cpu_ldl_kernel(CPUX86State *env, target_ulong ptr);
uint64_t cpu_ldq_kernel(CPUX86State *env, target_ulong ptr);
void cpu_stb_kernel(CPUX86State *env, target_ulong ptr, uint32_t data);
void cpu_stw_kernel(CPUX86State *env, target_ulong ptr, uint32_t data);
void cpu_stl_kernel(CPUX86State *env, target_ulong ptr, uint32_t data);
void cpu_stq_kernel(CPUX86State *env, target_ulong ptr, uint64_t data);
#endif /* CPU_I386_H */ #endif /* CPU_I386_H */

4
target-i386/fpu_helper.c
View File

@ -21,6 +21,10 @@
#include "cpu.h" #include "cpu.h"
#include "helper.h" #include "helper.h"
#if !defined(CONFIG_USER_ONLY)
#include "softmmu_exec.h"
#endif /* !defined(CONFIG_USER_ONLY) */
#define FPU_RC_MASK 0xc00 #define FPU_RC_MASK 0xc00
#define FPU_RC_NEAR 0x000 #define FPU_RC_NEAR 0x000
#define FPU_RC_DOWN 0x400 #define FPU_RC_DOWN 0x400

8
target-i386/helper.h
View File

@ -69,13 +69,13 @@ DEF_HELPER_1(cli, void, env)
DEF_HELPER_1(sti, void, env) DEF_HELPER_1(sti, void, env)
DEF_HELPER_1(set_inhibit_irq, void, env) DEF_HELPER_1(set_inhibit_irq, void, env)
DEF_HELPER_1(reset_inhibit_irq, void, env) DEF_HELPER_1(reset_inhibit_irq, void, env)
DEF_HELPER_2(boundw, void, tl, int) DEF_HELPER_3(boundw, void, env, tl, int)
DEF_HELPER_2(boundl, void, tl, int) DEF_HELPER_3(boundl, void, env, tl, int)
DEF_HELPER_1(rsm, void, env) DEF_HELPER_1(rsm, void, env)
DEF_HELPER_2(into, void, env, int) DEF_HELPER_2(into, void, env, int)
DEF_HELPER_1(cmpxchg8b, void, tl) DEF_HELPER_2(cmpxchg8b, void, env, tl)
#ifdef TARGET_X86_64 #ifdef TARGET_X86_64
DEF_HELPER_1(cmpxchg16b, void, tl) DEF_HELPER_2(cmpxchg16b, void, env, tl)
#endif #endif
DEF_HELPER_1(single_step, void, env) DEF_HELPER_1(single_step, void, env)
DEF_HELPER_1(cpuid, void, env) DEF_HELPER_1(cpuid, void, env)

101
target-i386/mem_helper.c
View File

@ -18,7 +18,6 @@
*/ */
#include "cpu.h" #include "cpu.h"
#include "dyngen-exec.h"
#include "helper.h" #include "helper.h"
#if !defined(CONFIG_USER_ONLY) #if !defined(CONFIG_USER_ONLY)
@ -39,19 +38,19 @@ void helper_unlock(void)
spin_unlock(&global_cpu_lock); spin_unlock(&global_cpu_lock);
} }
void helper_cmpxchg8b(target_ulong a0) void helper_cmpxchg8b(CPUX86State *env, target_ulong a0)
{ {
uint64_t d; uint64_t d;
int eflags; int eflags;
eflags = cpu_cc_compute_all(env, CC_OP); eflags = cpu_cc_compute_all(env, CC_OP);
d = ldq(a0); d = cpu_ldq_data(env, a0);
if (d == (((uint64_t)EDX << 32) | (uint32_t)EAX)) { if (d == (((uint64_t)EDX << 32) | (uint32_t)EAX)) {
stq(a0, ((uint64_t)ECX << 32) | (uint32_t)EBX); cpu_stq_data(env, a0, ((uint64_t)ECX << 32) | (uint32_t)EBX);
eflags |= CC_Z; eflags |= CC_Z;
} else { } else {
/* always do the store */ /* always do the store */
stq(a0, d); cpu_stq_data(env, a0, d);
EDX = (uint32_t)(d >> 32); EDX = (uint32_t)(d >> 32);
EAX = (uint32_t)d; EAX = (uint32_t)d;
eflags &= ~CC_Z; eflags &= ~CC_Z;
@ -60,7 +59,7 @@ void helper_cmpxchg8b(target_ulong a0)
} }
#ifdef TARGET_X86_64 #ifdef TARGET_X86_64
void helper_cmpxchg16b(target_ulong a0) void helper_cmpxchg16b(CPUX86State *env, target_ulong a0)
{ {
uint64_t d0, d1; uint64_t d0, d1;
int eflags; int eflags;
@ -69,16 +68,16 @@ void helper_cmpxchg16b(target_ulong a0)
raise_exception(env, EXCP0D_GPF); raise_exception(env, EXCP0D_GPF);
} }
eflags = cpu_cc_compute_all(env, CC_OP); eflags = cpu_cc_compute_all(env, CC_OP);
d0 = ldq(a0); d0 = cpu_ldq_data(env, a0);
d1 = ldq(a0 + 8); d1 = cpu_ldq_data(env, a0 + 8);
if (d0 == EAX && d1 == EDX) { if (d0 == EAX && d1 == EDX) {
stq(a0, EBX); cpu_stq_data(env, a0, EBX);
stq(a0 + 8, ECX); cpu_stq_data(env, a0 + 8, ECX);
eflags |= CC_Z; eflags |= CC_Z;
} else { } else {
/* always do the store */ /* always do the store */
stq(a0, d0); cpu_stq_data(env, a0, d0);
stq(a0 + 8, d1); cpu_stq_data(env, a0 + 8, d1);
EDX = d1; EDX = d1;
EAX = d0; EAX = d0;
eflags &= ~CC_Z; eflags &= ~CC_Z;
@ -87,24 +86,24 @@ void helper_cmpxchg16b(target_ulong a0)
} }
#endif #endif
void helper_boundw(target_ulong a0, int v) void helper_boundw(CPUX86State *env, target_ulong a0, int v)
{ {
int low, high; int low, high;
low = ldsw(a0); low = cpu_ldsw_data(env, a0);
high = ldsw(a0 + 2); high = cpu_ldsw_data(env, a0 + 2);
v = (int16_t)v; v = (int16_t)v;
if (v < low || v > high) { if (v < low || v > high) {
raise_exception(env, EXCP05_BOUND); raise_exception(env, EXCP05_BOUND);
} }
} }
void helper_boundl(target_ulong a0, int v) void helper_boundl(CPUX86State *env, target_ulong a0, int v)
{ {
int low, high; int low, high;
low = ldl(a0); low = cpu_ldl_data(env, a0);
high = ldl(a0 + 4); high = cpu_ldl_data(env, a0 + 4);
if (v < low || v > high) { if (v < low || v > high) {
raise_exception(env, EXCP05_BOUND); raise_exception(env, EXCP05_BOUND);
} }
@ -133,15 +132,11 @@ void helper_boundl(target_ulong a0, int v)
NULL, it means that the function was called in C code (i.e. not NULL, it means that the function was called in C code (i.e. not
from generated code or from helper.c) */ from generated code or from helper.c) */
/* XXX: fix it to restore all registers */ /* XXX: fix it to restore all registers */
void tlb_fill(CPUX86State *env1, target_ulong addr, int is_write, int mmu_idx, void tlb_fill(CPUX86State *env, target_ulong addr, int is_write, int mmu_idx,
uintptr_t retaddr) uintptr_t retaddr)
{ {
TranslationBlock *tb; TranslationBlock *tb;
int ret; int ret;
CPUX86State *saved_env;
saved_env = env;
env = env1;
ret = cpu_x86_handle_mmu_fault(env, addr, is_write, mmu_idx); ret = cpu_x86_handle_mmu_fault(env, addr, is_write, mmu_idx);
if (ret) { if (ret) {
@ -156,65 +151,5 @@ void tlb_fill(CPUX86State *env1, target_ulong addr, int is_write, int mmu_idx,
} }
raise_exception_err(env, env->exception_index, env->error_code); raise_exception_err(env, env->exception_index, env->error_code);
} }
env = saved_env;
} }
#endif #endif
/* temporary wrappers */
#if defined(CONFIG_USER_ONLY)
#define ldub_data(addr) ldub_raw(addr)
#define lduw_data(addr) lduw_raw(addr)
#define ldl_data(addr) ldl_raw(addr)
#define ldq_data(addr) ldq_raw(addr)
#define stb_data(addr, data) stb_raw(addr, data)
#define stw_data(addr, data) stw_raw(addr, data)
#define stl_data(addr, data) stl_raw(addr, data)
#define stq_data(addr, data) stq_raw(addr, data)
#endif
#define WRAP_LD(rettype, fn) \
rettype cpu_ ## fn(CPUX86State *env1, target_ulong addr) \
{ \
CPUX86State *saved_env; \
rettype ret; \
\
saved_env = env; \
env = env1; \
ret = fn(addr); \
env = saved_env; \
return ret; \
}
WRAP_LD(uint32_t, ldub_data)
WRAP_LD(uint32_t, lduw_data)
WRAP_LD(uint32_t, ldl_data)
WRAP_LD(uint64_t, ldq_data)
WRAP_LD(uint32_t, ldub_kernel)
WRAP_LD(uint32_t, lduw_kernel)
WRAP_LD(uint32_t, ldl_kernel)
WRAP_LD(uint64_t, ldq_kernel)
#undef WRAP_LD
#define WRAP_ST(datatype, fn) \
void cpu_ ## fn(CPUX86State *env1, target_ulong addr, datatype val) \
{ \
CPUX86State *saved_env; \
\
saved_env = env; \
env = env1; \
fn(addr, val); \
env = saved_env; \
}
WRAP_ST(uint32_t, stb_data)
WRAP_ST(uint32_t, stw_data)
WRAP_ST(uint32_t, stl_data)
WRAP_ST(uint64_t, stq_data)
WRAP_ST(uint32_t, stb_kernel)
WRAP_ST(uint32_t, stw_kernel)
WRAP_ST(uint32_t, stl_kernel)
WRAP_ST(uint64_t, stq_kernel)
#undef WRAP_ST

4
target-i386/misc_helper.c
View File

@ -21,6 +21,10 @@
#include "ioport.h" #include "ioport.h"
#include "helper.h" #include "helper.h"
#if !defined(CONFIG_USER_ONLY)
#include "softmmu_exec.h"
#endif /* !defined(CONFIG_USER_ONLY) */
/* check if Port I/O is allowed in TSS */ /* check if Port I/O is allowed in TSS */
static inline void check_io(CPUX86State *env, int addr, int size) static inline void check_io(CPUX86State *env, int addr, int size)
{ {

4
target-i386/seg_helper.c
View File

@ -24,6 +24,10 @@
//#define DEBUG_PCALL //#define DEBUG_PCALL
#if !defined(CONFIG_USER_ONLY)
#include "softmmu_exec.h"
#endif /* !defined(CONFIG_USER_ONLY) */
#ifdef DEBUG_PCALL #ifdef DEBUG_PCALL
# define LOG_PCALL(...) qemu_log_mask(CPU_LOG_PCALL, ## __VA_ARGS__) # define LOG_PCALL(...) qemu_log_mask(CPU_LOG_PCALL, ## __VA_ARGS__)
# define LOG_PCALL_STATE(env) \ # define LOG_PCALL_STATE(env) \

4
target-i386/svm_helper.c
View File

@ -21,6 +21,10 @@
#include "cpu-all.h" #include "cpu-all.h"
#include "helper.h" #include "helper.h"
#if !defined(CONFIG_USER_ONLY)
#include "softmmu_exec.h"
#endif /* !defined(CONFIG_USER_ONLY) */
/* Secure Virtual Machine helpers */ /* Secure Virtual Machine helpers */
#if defined(CONFIG_USER_ONLY) #if defined(CONFIG_USER_ONLY)

179
target-i386/translate.c
View File

@ -2043,7 +2043,7 @@ static void gen_lea_modrm(DisasContext *s, int modrm, int *reg_ptr, int *offset_
if (base == 4) { if (base == 4) {
havesib = 1; havesib = 1;
code = ldub_code(s->pc++); code = cpu_ldub_code(cpu_single_env, s->pc++);
scale = (code >> 6) & 3; scale = (code >> 6) & 3;
index = ((code >> 3) & 7) | REX_X(s); index = ((code >> 3) & 7) | REX_X(s);
base = (code & 7); base = (code & 7);
@ -2054,7 +2054,7 @@ static void gen_lea_modrm(DisasContext *s, int modrm, int *reg_ptr, int *offset_
case 0: case 0:
if ((base & 7) == 5) { if ((base & 7) == 5) {
base = -1; base = -1;
disp = (int32_t)ldl_code(s->pc); disp = (int32_t)cpu_ldl_code(cpu_single_env, s->pc);
s->pc += 4; s->pc += 4;
if (CODE64(s) && !havesib) { if (CODE64(s) && !havesib) {
disp += s->pc + s->rip_offset; disp += s->pc + s->rip_offset;
@ -2064,11 +2064,11 @@ static void gen_lea_modrm(DisasContext *s, int modrm, int *reg_ptr, int *offset_
} }
break; break;
case 1: case 1:
disp = (int8_t)ldub_code(s->pc++); disp = (int8_t)cpu_ldub_code(cpu_single_env, s->pc++);
break; break;
default: default:
case 2: case 2:
disp = (int32_t)ldl_code(s->pc); disp = (int32_t)cpu_ldl_code(cpu_single_env, s->pc);
s->pc += 4; s->pc += 4;
break; break;
} }
@ -2131,7 +2131,7 @@ static void gen_lea_modrm(DisasContext *s, int modrm, int *reg_ptr, int *offset_
switch (mod) { switch (mod) {
case 0: case 0:
if (rm == 6) { if (rm == 6) {
disp = lduw_code(s->pc); disp = cpu_lduw_code(cpu_single_env, s->pc);
s->pc += 2; s->pc += 2;
gen_op_movl_A0_im(disp); gen_op_movl_A0_im(disp);
rm = 0; /* avoid SS override */ rm = 0; /* avoid SS override */
@ -2141,11 +2141,11 @@ static void gen_lea_modrm(DisasContext *s, int modrm, int *reg_ptr, int *offset_
} }
break; break;
case 1: case 1:
disp = (int8_t)ldub_code(s->pc++); disp = (int8_t)cpu_ldub_code(cpu_single_env, s->pc++);
break; break;
default: default:
case 2: case 2:
disp = lduw_code(s->pc); disp = cpu_lduw_code(cpu_single_env, s->pc);
s->pc += 2; s->pc += 2;
break; break;
} }
@ -2215,7 +2215,7 @@ static void gen_nop_modrm(DisasContext *s, int modrm)
base = rm; base = rm;
if (base == 4) { if (base == 4) {
code = ldub_code(s->pc++); code = cpu_ldub_code(cpu_single_env, s->pc++);
base = (code & 7); base = (code & 7);
} }
@ -2311,16 +2311,16 @@ static inline uint32_t insn_get(DisasContext *s, int ot)
switch(ot) { switch(ot) {
case OT_BYTE: case OT_BYTE:
ret = ldub_code(s->pc); ret = cpu_ldub_code(cpu_single_env, s->pc);
s->pc++; s->pc++;
break; break;
case OT_WORD: case OT_WORD:
ret = lduw_code(s->pc); ret = cpu_lduw_code(cpu_single_env, s->pc);
s->pc += 2; s->pc += 2;
break; break;
default: default:
case OT_LONG: case OT_LONG:
ret = ldl_code(s->pc); ret = cpu_ldl_code(cpu_single_env, s->pc);
s->pc += 4; s->pc += 4;
break; break;
} }
@ -3229,7 +3229,7 @@ static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
gen_helper_enter_mmx(cpu_env); gen_helper_enter_mmx(cpu_env);
} }
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7); reg = ((modrm >> 3) & 7);
if (is_xmm) if (is_xmm)
reg |= rex_r; reg |= rex_r;
@ -3433,8 +3433,8 @@ static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
if (b1 == 1 && reg != 0) if (b1 == 1 && reg != 0)
goto illegal_op; goto illegal_op;
field_length = ldub_code(s->pc++) & 0x3F; field_length = cpu_ldub_code(cpu_single_env, s->pc++) & 0x3F;
bit_index = ldub_code(s->pc++) & 0x3F; bit_index = cpu_ldub_code(cpu_single_env, s->pc++) & 0x3F;
tcg_gen_addi_ptr(cpu_ptr0, cpu_env, tcg_gen_addi_ptr(cpu_ptr0, cpu_env,
offsetof(CPUX86State,xmm_regs[reg])); offsetof(CPUX86State,xmm_regs[reg]));
if (b1 == 1) if (b1 == 1)
@ -3559,7 +3559,7 @@ static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
if (b1 >= 2) { if (b1 >= 2) {
goto illegal_op; goto illegal_op;
} }
val = ldub_code(s->pc++); val = cpu_ldub_code(cpu_single_env, s->pc++);
if (is_xmm) { if (is_xmm) {
gen_op_movl_T0_im(val); gen_op_movl_T0_im(val);
tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_t0.XMM_L(0))); tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_t0.XMM_L(0)));
@ -3718,7 +3718,7 @@ static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
case 0x1c4: case 0x1c4:
s->rip_offset = 1; s->rip_offset = 1;
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0); gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
val = ldub_code(s->pc++); val = cpu_ldub_code(cpu_single_env, s->pc++);
if (b1) { if (b1) {
val &= 7; val &= 7;
tcg_gen_st16_tl(cpu_T[0], cpu_env, tcg_gen_st16_tl(cpu_T[0], cpu_env,
@ -3734,7 +3734,7 @@ static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
if (mod != 3) if (mod != 3)
goto illegal_op; goto illegal_op;
ot = (s->dflag == 2) ? OT_QUAD : OT_LONG; ot = (s->dflag == 2) ? OT_QUAD : OT_LONG;
val = ldub_code(s->pc++); val = cpu_ldub_code(cpu_single_env, s->pc++);
if (b1) { if (b1) {
val &= 7; val &= 7;
rm = (modrm & 7) | REX_B(s); rm = (modrm & 7) | REX_B(s);
@ -3795,7 +3795,7 @@ static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
goto crc32; goto crc32;
case 0x038: case 0x038:
b = modrm; b = modrm;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
rm = modrm & 7; rm = modrm & 7;
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
@ -3869,7 +3869,7 @@ static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
case 0x338: /* crc32 */ case 0x338: /* crc32 */
crc32: crc32:
b = modrm; b = modrm;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
if (b != 0xf0 && b != 0xf1) if (b != 0xf0 && b != 0xf1)
@ -3899,7 +3899,7 @@ static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
case 0x03a: case 0x03a:
case 0x13a: case 0x13a:
b = modrm; b = modrm;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
rm = modrm & 7; rm = modrm & 7;
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
@ -3920,7 +3920,7 @@ static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
if (mod != 3) if (mod != 3)
gen_lea_modrm(s, modrm, &reg_addr, &offset_addr); gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
val = ldub_code(s->pc++); val = cpu_ldub_code(cpu_single_env, s->pc++);
switch (b) { switch (b) {
case 0x14: /* pextrb */ case 0x14: /* pextrb */
tcg_gen_ld8u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, tcg_gen_ld8u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,
@ -4063,7 +4063,7 @@ static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
gen_ldq_env_A0(s->mem_index, op2_offset); gen_ldq_env_A0(s->mem_index, op2_offset);
} }
} }
val = ldub_code(s->pc++); val = cpu_ldub_code(cpu_single_env, s->pc++);
if ((b & 0xfc) == 0x60) { /* pcmpXstrX */ if ((b & 0xfc) == 0x60) { /* pcmpXstrX */
s->cc_op = CC_OP_EFLAGS; s->cc_op = CC_OP_EFLAGS;
@ -4129,7 +4129,7 @@ static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
case 0x0f: /* 3DNow! data insns */ case 0x0f: /* 3DNow! data insns */
if (!(s->cpuid_ext2_features & CPUID_EXT2_3DNOW)) if (!(s->cpuid_ext2_features & CPUID_EXT2_3DNOW))
goto illegal_op; goto illegal_op;
val = ldub_code(s->pc++); val = cpu_ldub_code(cpu_single_env, s->pc++);
sse_fn_epp = sse_op_table5[val]; sse_fn_epp = sse_op_table5[val];
if (!sse_fn_epp) { if (!sse_fn_epp) {
goto illegal_op; goto illegal_op;
@ -4140,7 +4140,7 @@ static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
break; break;
case 0x70: /* pshufx insn */ case 0x70: /* pshufx insn */
case 0xc6: /* pshufx insn */ case 0xc6: /* pshufx insn */
val = ldub_code(s->pc++); val = cpu_ldub_code(cpu_single_env, s->pc++);
tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset); tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset); tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
/* XXX: introduce a new table? */ /* XXX: introduce a new table? */
@ -4149,7 +4149,7 @@ static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
break; break;
case 0xc2: case 0xc2:
/* compare insns */ /* compare insns */
val = ldub_code(s->pc++); val = cpu_ldub_code(cpu_single_env, s->pc++);
if (val >= 8) if (val >= 8)
goto illegal_op; goto illegal_op;
sse_fn_epp = sse_op_table4[val][b1]; sse_fn_epp = sse_op_table4[val][b1];
@ -4218,7 +4218,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
#endif #endif
s->rip_offset = 0; /* for relative ip address */ s->rip_offset = 0; /* for relative ip address */
next_byte: next_byte:
b = ldub_code(s->pc); b = cpu_ldub_code(cpu_single_env, s->pc);
s->pc++; s->pc++;
/* check prefixes */ /* check prefixes */
#ifdef TARGET_X86_64 #ifdef TARGET_X86_64
@ -4333,7 +4333,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
case 0x0f: case 0x0f:
/**************************/ /**************************/
/* extended op code */ /* extended op code */
b = ldub_code(s->pc++) | 0x100; b = cpu_ldub_code(cpu_single_env, s->pc++) | 0x100;
goto reswitch; goto reswitch;
/**************************/ /**************************/
@ -4358,7 +4358,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
switch(f) { switch(f) {
case 0: /* OP Ev, Gv */ case 0: /* OP Ev, Gv */
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s); rm = (modrm & 7) | REX_B(s);
@ -4380,7 +4380,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
gen_op(s, op, ot, opreg); gen_op(s, op, ot, opreg);
break; break;
case 1: /* OP Gv, Ev */ case 1: /* OP Gv, Ev */
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
rm = (modrm & 7) | REX_B(s); rm = (modrm & 7) | REX_B(s);
@ -4417,7 +4417,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
else else
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s); rm = (modrm & 7) | REX_B(s);
op = (modrm >> 3) & 7; op = (modrm >> 3) & 7;
@ -4466,7 +4466,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
else else
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s); rm = (modrm & 7) | REX_B(s);
op = (modrm >> 3) & 7; op = (modrm >> 3) & 7;
@ -4698,7 +4698,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
else else
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s); rm = (modrm & 7) | REX_B(s);
op = (modrm >> 3) & 7; op = (modrm >> 3) & 7;
@ -4810,7 +4810,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
else else
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0); gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
@ -4875,7 +4875,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
case 0x69: /* imul Gv, Ev, I */ case 0x69: /* imul Gv, Ev, I */
case 0x6b: case 0x6b:
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
if (b == 0x69) if (b == 0x69)
s->rip_offset = insn_const_size(ot); s->rip_offset = insn_const_size(ot);
@ -4939,7 +4939,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
ot = OT_BYTE; ot = OT_BYTE;
else else
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
if (mod == 3) { if (mod == 3) {
@ -4970,7 +4970,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
ot = OT_BYTE; ot = OT_BYTE;
else else
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
t0 = tcg_temp_local_new(); t0 = tcg_temp_local_new();
@ -5018,7 +5018,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
} }
break; break;
case 0x1c7: /* cmpxchg8b */ case 0x1c7: /* cmpxchg8b */
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
if ((mod == 3) || ((modrm & 0x38) != 0x8)) if ((mod == 3) || ((modrm & 0x38) != 0x8))
goto illegal_op; goto illegal_op;
@ -5030,7 +5030,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
if (s->cc_op != CC_OP_DYNAMIC) if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op); gen_op_set_cc_op(s->cc_op);
gen_lea_modrm(s, modrm, &reg_addr, &offset_addr); gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
gen_helper_cmpxchg16b(cpu_A0); gen_helper_cmpxchg16b(cpu_env, cpu_A0);
} else } else
#endif #endif
{ {
@ -5040,7 +5040,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
if (s->cc_op != CC_OP_DYNAMIC) if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op); gen_op_set_cc_op(s->cc_op);
gen_lea_modrm(s, modrm, &reg_addr, &offset_addr); gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
gen_helper_cmpxchg8b(cpu_A0); gen_helper_cmpxchg8b(cpu_env, cpu_A0);
} }
s->cc_op = CC_OP_EFLAGS; s->cc_op = CC_OP_EFLAGS;
break; break;
@ -5092,7 +5092,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
} else { } else {
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
} }
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
gen_pop_T0(s); gen_pop_T0(s);
if (mod == 3) { if (mod == 3) {
@ -5111,9 +5111,9 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
case 0xc8: /* enter */ case 0xc8: /* enter */
{ {
int level; int level;
val = lduw_code(s->pc); val = cpu_lduw_code(cpu_single_env, s->pc);
s->pc += 2; s->pc += 2;
level = ldub_code(s->pc++); level = cpu_ldub_code(cpu_single_env, s->pc++);
gen_enter(s, val, level); gen_enter(s, val, level);
} }
break; break;
@ -5193,7 +5193,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
ot = OT_BYTE; ot = OT_BYTE;
else else
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
/* generate a generic store */ /* generate a generic store */
@ -5205,7 +5205,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
ot = OT_BYTE; ot = OT_BYTE;
else else
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
if (mod != 3) { if (mod != 3) {
s->rip_offset = insn_const_size(ot); s->rip_offset = insn_const_size(ot);
@ -5224,14 +5224,14 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
ot = OT_BYTE; ot = OT_BYTE;
else else
ot = OT_WORD + dflag; ot = OT_WORD + dflag;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0); gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_mov_reg_T0(ot, reg); gen_op_mov_reg_T0(ot, reg);
break; break;
case 0x8e: /* mov seg, Gv */ case 0x8e: /* mov seg, Gv */
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = (modrm >> 3) & 7; reg = (modrm >> 3) & 7;
if (reg >= 6 || reg == R_CS) if (reg >= 6 || reg == R_CS)
goto illegal_op; goto illegal_op;
@ -5251,7 +5251,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
} }
break; break;
case 0x8c: /* mov Gv, seg */ case 0x8c: /* mov Gv, seg */
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = (modrm >> 3) & 7; reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
if (reg >= 6) if (reg >= 6)
@ -5274,7 +5274,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
d_ot = dflag + OT_WORD; d_ot = dflag + OT_WORD;
/* ot is the size of source */ /* ot is the size of source */
ot = (b & 1) + OT_BYTE; ot = (b & 1) + OT_BYTE;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s); rm = (modrm & 7) | REX_B(s);
@ -5311,7 +5311,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
case 0x8d: /* lea */ case 0x8d: /* lea */
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
if (mod == 3) if (mod == 3)
goto illegal_op; goto illegal_op;
@ -5338,7 +5338,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
#ifdef TARGET_X86_64 #ifdef TARGET_X86_64
if (s->aflag == 2) { if (s->aflag == 2) {
offset_addr = ldq_code(s->pc); offset_addr = cpu_ldq_code(cpu_single_env, s->pc);
s->pc += 8; s->pc += 8;
gen_op_movq_A0_im(offset_addr); gen_op_movq_A0_im(offset_addr);
} else } else
@ -5394,7 +5394,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
if (dflag == 2) { if (dflag == 2) {
uint64_t tmp; uint64_t tmp;
/* 64 bit case */ /* 64 bit case */
tmp = ldq_code(s->pc); tmp = cpu_ldq_code(cpu_single_env, s->pc);
s->pc += 8; s->pc += 8;
reg = (b & 7) | REX_B(s); reg = (b & 7) | REX_B(s);
gen_movtl_T0_im(tmp); gen_movtl_T0_im(tmp);
@ -5422,7 +5422,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
ot = OT_BYTE; ot = OT_BYTE;
else else
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
if (mod == 3) { if (mod == 3) {
@ -5465,7 +5465,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
op = R_GS; op = R_GS;
do_lxx: do_lxx:
ot = dflag ? OT_LONG : OT_WORD; ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
if (mod == 3) if (mod == 3)
@ -5497,7 +5497,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
else else
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7; op = (modrm >> 3) & 7;
@ -5516,7 +5516,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
gen_shift(s, op, ot, opreg, OR_ECX); gen_shift(s, op, ot, opreg, OR_ECX);
} else { } else {
if (shift == 2) { if (shift == 2) {
shift = ldub_code(s->pc++); shift = cpu_ldub_code(cpu_single_env, s->pc++);
} }
gen_shifti(s, op, ot, opreg, shift); gen_shifti(s, op, ot, opreg, shift);
} }
@ -5550,7 +5550,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
shift = 0; shift = 0;
do_shiftd: do_shiftd:
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s); rm = (modrm & 7) | REX_B(s);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
@ -5563,7 +5563,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
gen_op_mov_TN_reg(ot, 1, reg); gen_op_mov_TN_reg(ot, 1, reg);
if (shift) { if (shift) {
val = ldub_code(s->pc++); val = cpu_ldub_code(cpu_single_env, s->pc++);
tcg_gen_movi_tl(cpu_T3, val); tcg_gen_movi_tl(cpu_T3, val);
} else { } else {
tcg_gen_mov_tl(cpu_T3, cpu_regs[R_ECX]); tcg_gen_mov_tl(cpu_T3, cpu_regs[R_ECX]);
@ -5580,7 +5580,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base); gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
break; break;
} }
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
rm = modrm & 7; rm = modrm & 7;
op = ((b & 7) << 3) | ((modrm >> 3) & 7); op = ((b & 7) << 3) | ((modrm >> 3) & 7);
@ -6211,7 +6211,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
ot = OT_BYTE; ot = OT_BYTE;
else else
ot = dflag ? OT_LONG : OT_WORD; ot = dflag ? OT_LONG : OT_WORD;
val = ldub_code(s->pc++); val = cpu_ldub_code(cpu_single_env, s->pc++);
gen_op_movl_T0_im(val); gen_op_movl_T0_im(val);
gen_check_io(s, ot, pc_start - s->cs_base, gen_check_io(s, ot, pc_start - s->cs_base,
SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes)); SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes));
@ -6231,7 +6231,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
ot = OT_BYTE; ot = OT_BYTE;
else else
ot = dflag ? OT_LONG : OT_WORD; ot = dflag ? OT_LONG : OT_WORD;
val = ldub_code(s->pc++); val = cpu_ldub_code(cpu_single_env, s->pc++);
gen_op_movl_T0_im(val); gen_op_movl_T0_im(val);
gen_check_io(s, ot, pc_start - s->cs_base, gen_check_io(s, ot, pc_start - s->cs_base,
svm_is_rep(prefixes)); svm_is_rep(prefixes));
@ -6293,7 +6293,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
/************************/ /************************/
/* control */ /* control */
case 0xc2: /* ret im */ case 0xc2: /* ret im */
val = ldsw_code(s->pc); val = cpu_ldsw_code(cpu_single_env, s->pc);
s->pc += 2; s->pc += 2;
gen_pop_T0(s); gen_pop_T0(s);
if (CODE64(s) && s->dflag) if (CODE64(s) && s->dflag)
@ -6313,7 +6313,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
gen_eob(s); gen_eob(s);
break; break;
case 0xca: /* lret im */ case 0xca: /* lret im */
val = ldsw_code(s->pc); val = cpu_ldsw_code(cpu_single_env, s->pc);
s->pc += 2; s->pc += 2;
do_lret: do_lret:
if (s->pe && !s->vm86) { if (s->pe && !s->vm86) {
@ -6448,7 +6448,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
break; break;
case 0x190 ... 0x19f: /* setcc Gv */ case 0x190 ... 0x19f: /* setcc Gv */
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
gen_setcc(s, b); gen_setcc(s, b);
gen_ldst_modrm(s, modrm, OT_BYTE, OR_TMP0, 1); gen_ldst_modrm(s, modrm, OT_BYTE, OR_TMP0, 1);
break; break;
@ -6458,7 +6458,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
TCGv t0; TCGv t0;
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
t0 = tcg_temp_local_new(); t0 = tcg_temp_local_new();
@ -6616,7 +6616,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
/* bit operations */ /* bit operations */
case 0x1ba: /* bt/bts/btr/btc Gv, im */ case 0x1ba: /* bt/bts/btr/btc Gv, im */
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
op = (modrm >> 3) & 7; op = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s); rm = (modrm & 7) | REX_B(s);
@ -6628,7 +6628,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
gen_op_mov_TN_reg(ot, 0, rm); gen_op_mov_TN_reg(ot, 0, rm);
} }
/* load shift */ /* load shift */
val = ldub_code(s->pc++); val = cpu_ldub_code(cpu_single_env, s->pc++);
gen_op_movl_T1_im(val); gen_op_movl_T1_im(val);
if (op < 4) if (op < 4)
goto illegal_op; goto illegal_op;
@ -6647,7 +6647,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
op = 3; op = 3;
do_btx: do_btx:
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s); rm = (modrm & 7) | REX_B(s);
@ -6708,7 +6708,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
TCGv t0; TCGv t0;
ot = dflag + OT_WORD; ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
gen_ldst_modrm(s,modrm, ot, OR_TMP0, 0); gen_ldst_modrm(s,modrm, ot, OR_TMP0, 0);
gen_extu(ot, cpu_T[0]); gen_extu(ot, cpu_T[0]);
@ -6780,7 +6780,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
case 0xd4: /* aam */ case 0xd4: /* aam */
if (CODE64(s)) if (CODE64(s))
goto illegal_op; goto illegal_op;
val = ldub_code(s->pc++); val = cpu_ldub_code(cpu_single_env, s->pc++);
if (val == 0) { if (val == 0) {
gen_exception(s, EXCP00_DIVZ, pc_start - s->cs_base); gen_exception(s, EXCP00_DIVZ, pc_start - s->cs_base);
} else { } else {
@ -6791,7 +6791,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
case 0xd5: /* aad */ case 0xd5: /* aad */
if (CODE64(s)) if (CODE64(s))
goto illegal_op; goto illegal_op;
val = ldub_code(s->pc++); val = cpu_ldub_code(cpu_single_env, s->pc++);
gen_helper_aad(cpu_env, tcg_const_i32(val)); gen_helper_aad(cpu_env, tcg_const_i32(val));
s->cc_op = CC_OP_LOGICB; s->cc_op = CC_OP_LOGICB;
break; break;
@ -6825,7 +6825,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
gen_interrupt(s, EXCP03_INT3, pc_start - s->cs_base, s->pc - s->cs_base); gen_interrupt(s, EXCP03_INT3, pc_start - s->cs_base, s->pc - s->cs_base);
break; break;
case 0xcd: /* int N */ case 0xcd: /* int N */
val = ldub_code(s->pc++); val = cpu_ldub_code(cpu_single_env, s->pc++);
if (s->vm86 && s->iopl != 3) { if (s->vm86 && s->iopl != 3) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base); gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else { } else {
@ -6895,7 +6895,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
if (CODE64(s)) if (CODE64(s))
goto illegal_op; goto illegal_op;
ot = dflag ? OT_LONG : OT_WORD; ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = (modrm >> 3) & 7; reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
if (mod == 3) if (mod == 3)
@ -6904,10 +6904,11 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
gen_lea_modrm(s, modrm, &reg_addr, &offset_addr); gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
gen_jmp_im(pc_start - s->cs_base); gen_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]); tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
if (ot == OT_WORD) if (ot == OT_WORD) {
gen_helper_boundw(cpu_A0, cpu_tmp2_i32); gen_helper_boundw(cpu_env, cpu_A0, cpu_tmp2_i32);
else } else {
gen_helper_boundl(cpu_A0, cpu_tmp2_i32); gen_helper_boundl(cpu_env, cpu_A0, cpu_tmp2_i32);
}
break; break;
case 0x1c8 ... 0x1cf: /* bswap reg */ case 0x1c8 ... 0x1cf: /* bswap reg */
reg = (b & 7) | REX_B(s); reg = (b & 7) | REX_B(s);
@ -7085,7 +7086,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
} }
break; break;
case 0x100: case 0x100:
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7; op = (modrm >> 3) & 7;
switch(op) { switch(op) {
@ -7154,7 +7155,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
} }
break; break;
case 0x101: case 0x101:
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7; op = (modrm >> 3) & 7;
rm = modrm & 7; rm = modrm & 7;
@ -7421,7 +7422,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
/* d_ot is the size of destination */ /* d_ot is the size of destination */
d_ot = dflag + OT_WORD; d_ot = dflag + OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s); rm = (modrm & 7) | REX_B(s);
@ -7453,7 +7454,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
t1 = tcg_temp_local_new(); t1 = tcg_temp_local_new();
t2 = tcg_temp_local_new(); t2 = tcg_temp_local_new();
ot = OT_WORD; ot = OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = (modrm >> 3) & 7; reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
rm = modrm & 7; rm = modrm & 7;
@ -7501,7 +7502,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
if (!s->pe || s->vm86) if (!s->pe || s->vm86)
goto illegal_op; goto illegal_op;
ot = dflag ? OT_LONG : OT_WORD; ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r; reg = ((modrm >> 3) & 7) | rex_r;
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0); gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
t0 = tcg_temp_local_new(); t0 = tcg_temp_local_new();
@ -7522,7 +7523,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
} }
break; break;
case 0x118: case 0x118:
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7; op = (modrm >> 3) & 7;
switch(op) { switch(op) {
@ -7541,7 +7542,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
} }
break; break;
case 0x119 ... 0x11f: /* nop (multi byte) */ case 0x119 ... 0x11f: /* nop (multi byte) */
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
gen_nop_modrm(s, modrm); gen_nop_modrm(s, modrm);
break; break;
case 0x120: /* mov reg, crN */ case 0x120: /* mov reg, crN */
@ -7549,7 +7550,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
if (s->cpl != 0) { if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base); gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else { } else {
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
if ((modrm & 0xc0) != 0xc0) if ((modrm & 0xc0) != 0xc0)
goto illegal_op; goto illegal_op;
rm = (modrm & 7) | REX_B(s); rm = (modrm & 7) | REX_B(s);
@ -7592,7 +7593,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
if (s->cpl != 0) { if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base); gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else { } else {
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
if ((modrm & 0xc0) != 0xc0) if ((modrm & 0xc0) != 0xc0)
goto illegal_op; goto illegal_op;
rm = (modrm & 7) | REX_B(s); rm = (modrm & 7) | REX_B(s);
@ -7633,7 +7634,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
if (!(s->cpuid_features & CPUID_SSE2)) if (!(s->cpuid_features & CPUID_SSE2))
goto illegal_op; goto illegal_op;
ot = s->dflag == 2 ? OT_QUAD : OT_LONG; ot = s->dflag == 2 ? OT_QUAD : OT_LONG;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
if (mod == 3) if (mod == 3)
goto illegal_op; goto illegal_op;
@ -7642,7 +7643,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
gen_ldst_modrm(s, modrm, ot, reg, 1); gen_ldst_modrm(s, modrm, ot, reg, 1);
break; break;
case 0x1ae: case 0x1ae:
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7; op = (modrm >> 3) & 7;
switch(op) { switch(op) {
@ -7717,7 +7718,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
} }
break; break;
case 0x10d: /* 3DNow! prefetch(w) */ case 0x10d: /* 3DNow! prefetch(w) */
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3; mod = (modrm >> 6) & 3;
if (mod == 3) if (mod == 3)
goto illegal_op; goto illegal_op;
@ -7740,7 +7741,7 @@ static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
if (!(s->cpuid_ext_features & CPUID_EXT_POPCNT)) if (!(s->cpuid_ext_features & CPUID_EXT_POPCNT))
goto illegal_op; goto illegal_op;
modrm = ldub_code(s->pc++); modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7); reg = ((modrm >> 3) & 7);
if (s->prefix & PREFIX_DATA) if (s->prefix & PREFIX_DATA)