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

exec: Change cpu_memory_rw_debug() argument to CPUState

Browse Source 
Propagate X86CPU in kvmvapic for simplicity.

Signed-off-by: Andreas Färber <afaerber@suse.de>
This commit is contained in:
Andreas Färber 2013-06-29 19:40:58 +02:00
parent 00b941e581
commit f17ec444c3
13 changed files with 77 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cpus.c
View File

@ -1285,7 +1285,6 @@ void qmp_memsave(int64_t addr, int64_t size, const char *filename,
{ {
FILE *f; FILE *f;
uint32_t l; uint32_t l;
CPUArchState *env;
CPUState *cpu; CPUState *cpu;
uint8_t buf[1024]; uint8_t buf[1024];
@ -1299,7 +1298,6 @@ void qmp_memsave(int64_t addr, int64_t size, const char *filename,
"a CPU number"); "a CPU number");
return; return;
} }
env = cpu->env_ptr;
f = fopen(filename, "wb"); f = fopen(filename, "wb");
if (!f) { if (!f) {
@ -1311,7 +1309,7 @@ void qmp_memsave(int64_t addr, int64_t size, const char *filename,
l = sizeof(buf); l = sizeof(buf);
if (l > size) if (l > size)
l = size; l = size;
cpu_memory_rw_debug(env, addr, buf, l, 0); cpu_memory_rw_debug(cpu, addr, buf, l, 0);
if (fwrite(buf, 1, l, f) != l) { if (fwrite(buf, 1, l, f) != l) {
error_set(errp, QERR_IO_ERROR); error_set(errp, QERR_IO_ERROR);
goto exit; goto exit;

4
disas.c
View File

@ -39,7 +39,7 @@ target_read_memory (bfd_vma memaddr,
{ {
CPUDebug *s = container_of(info, CPUDebug, info); CPUDebug *s = container_of(info, CPUDebug, info);
cpu_memory_rw_debug(s->env, memaddr, myaddr, length, 0); cpu_memory_rw_debug(ENV_GET_CPU(s->env), memaddr, myaddr, length, 0);
return 0; return 0;
} }
@ -392,7 +392,7 @@ monitor_read_memory (bfd_vma memaddr, bfd_byte *myaddr, int length,
if (monitor_disas_is_physical) { if (monitor_disas_is_physical) {
cpu_physical_memory_read(memaddr, myaddr, length); cpu_physical_memory_read(memaddr, myaddr, length);
} else { } else {
cpu_memory_rw_debug(s->env, memaddr,myaddr, length, 0); cpu_memory_rw_debug(ENV_GET_CPU(s->env), memaddr, myaddr, length, 0);
} }
return 0; return 0;
} }

6
exec.c
View File

@ -1835,7 +1835,7 @@ MemoryRegion *get_system_io(void)
/* physical memory access (slow version, mainly for debug) */ /* physical memory access (slow version, mainly for debug) */
#if defined(CONFIG_USER_ONLY) #if defined(CONFIG_USER_ONLY)
int cpu_memory_rw_debug(CPUArchState *env, target_ulong addr, int cpu_memory_rw_debug(CPUState *cpu, target_ulong addr,
uint8_t *buf, int len, int is_write) uint8_t *buf, int len, int is_write)
{ {
int l, flags; int l, flags;
@ -2606,7 +2606,7 @@ void stq_be_phys(hwaddr addr, uint64_t val)
} }
/* virtual memory access for debug (includes writing to ROM) */ /* virtual memory access for debug (includes writing to ROM) */
int cpu_memory_rw_debug(CPUArchState *env, target_ulong addr, int cpu_memory_rw_debug(CPUState *cpu, target_ulong addr,
uint8_t *buf, int len, int is_write) uint8_t *buf, int len, int is_write)
{ {
int l; int l;
@ -2615,7 +2615,7 @@ int cpu_memory_rw_debug(CPUArchState *env, target_ulong addr,
while (len > 0) { while (len > 0) {
page = addr & TARGET_PAGE_MASK; page = addr & TARGET_PAGE_MASK;
phys_addr = cpu_get_phys_page_debug(ENV_GET_CPU(env), page); phys_addr = cpu_get_phys_page_debug(cpu, page);
/* if no physical page mapped, return an error */ /* if no physical page mapped, return an error */
if (phys_addr == -1) if (phys_addr == -1)
return -1; return -1;

2
gdbstub.c
View File

@ -46,7 +46,7 @@
static inline int target_memory_rw_debug(CPUArchState *env, target_ulong addr, static inline int target_memory_rw_debug(CPUArchState *env, target_ulong addr,
uint8_t *buf, int len, int is_write) uint8_t *buf, int len, int is_write)
{ {
return cpu_memory_rw_debug(env, addr, buf, len, is_write); return cpu_memory_rw_debug(ENV_GET_CPU(env), addr, buf, len, is_write);
} }
#else #else
/* target_memory_rw_debug() defined in cpu.h */ /* target_memory_rw_debug() defined in cpu.h */

72
hw/i386/kvmvapic.c
View File

@ -188,9 +188,10 @@ static bool opcode_matches(uint8_t *opcode, const TPRInstruction *instr)
modrm_reg(opcode[1]) == instr->modrm_reg); modrm_reg(opcode[1]) == instr->modrm_reg);
} }
static int evaluate_tpr_instruction(VAPICROMState *s, CPUX86State *env, static int evaluate_tpr_instruction(VAPICROMState *s, X86CPU *cpu,
target_ulong *pip, TPRAccess access) target_ulong *pip, TPRAccess access)
{ {
CPUState *cs = CPU(cpu);
const TPRInstruction *instr; const TPRInstruction *instr;
target_ulong ip = *pip; target_ulong ip = *pip;
uint8_t opcode[2]; uint8_t opcode[2];
@ -211,7 +212,7 @@ static int evaluate_tpr_instruction(VAPICROMState *s, CPUX86State *env,
* RSP, used by the patched instruction, is zero, so the guest gets a * RSP, used by the patched instruction, is zero, so the guest gets a
* double fault and dies. * double fault and dies.
*/ */
if (env->regs[R_ESP] == 0) { if (cpu->env.regs[R_ESP] == 0) {
return -1; return -1;
} }
@ -226,7 +227,7 @@ static int evaluate_tpr_instruction(VAPICROMState *s, CPUX86State *env,
if (instr->access != access) { if (instr->access != access) {
continue; continue;
} }
if (cpu_memory_rw_debug(env, ip - instr->length, opcode, if (cpu_memory_rw_debug(cs, ip - instr->length, opcode,
sizeof(opcode), 0) < 0) { sizeof(opcode), 0) < 0) {
return -1; return -1;
} }
@ -237,7 +238,7 @@ static int evaluate_tpr_instruction(VAPICROMState *s, CPUX86State *env,
} }
return -1; return -1;
} else { } else {
if (cpu_memory_rw_debug(env, ip, opcode, sizeof(opcode), 0) < 0) { if (cpu_memory_rw_debug(cs, ip, opcode, sizeof(opcode), 0) < 0) {
return -1; return -1;
} }
for (i = 0; i < ARRAY_SIZE(tpr_instr); i++) { for (i = 0; i < ARRAY_SIZE(tpr_instr); i++) {
@ -254,7 +255,7 @@ instruction_ok:
* Grab the virtual TPR address from the instruction * Grab the virtual TPR address from the instruction
* and update the cached values. * and update the cached values.
*/ */
if (cpu_memory_rw_debug(env, ip + instr->addr_offset, if (cpu_memory_rw_debug(cs, ip + instr->addr_offset,
(void *)&real_tpr_addr, (void *)&real_tpr_addr,
sizeof(real_tpr_addr), 0) < 0) { sizeof(real_tpr_addr), 0) < 0) {
return -1; return -1;
@ -334,8 +335,9 @@ static int update_rom_mapping(VAPICROMState *s, CPUX86State *env, target_ulong i
* cannot be accessed or is considered invalid. This also ensures that we are * cannot be accessed or is considered invalid. This also ensures that we are
* not patching the wrong guest. * not patching the wrong guest.
*/ */
static int get_kpcr_number(CPUX86State *env) static int get_kpcr_number(X86CPU *cpu)
{ {
CPUX86State *env = &cpu->env;
struct kpcr { struct kpcr {
uint8_t fill1[0x1c]; uint8_t fill1[0x1c];
uint32_t self; uint32_t self;
@ -343,7 +345,7 @@ static int get_kpcr_number(CPUX86State *env)
uint8_t number; uint8_t number;
} QEMU_PACKED kpcr; } QEMU_PACKED kpcr;
if (cpu_memory_rw_debug(env, env->segs[R_FS].base, if (cpu_memory_rw_debug(CPU(cpu), env->segs[R_FS].base,
(void *)&kpcr, sizeof(kpcr), 0) < 0 || (void *)&kpcr, sizeof(kpcr), 0) < 0 ||
kpcr.self != env->segs[R_FS].base) { kpcr.self != env->segs[R_FS].base) {
return -1; return -1;
@ -351,9 +353,9 @@ static int get_kpcr_number(CPUX86State *env)
return kpcr.number; return kpcr.number;
} }
static int vapic_enable(VAPICROMState *s, CPUX86State *env) static int vapic_enable(VAPICROMState *s, X86CPU *cpu)
{ {
int cpu_number = get_kpcr_number(env); int cpu_number = get_kpcr_number(cpu);
hwaddr vapic_paddr; hwaddr vapic_paddr;
static const uint8_t enabled = 1; static const uint8_t enabled = 1;
@ -364,26 +366,26 @@ static int vapic_enable(VAPICROMState *s, CPUX86State *env)
(((hwaddr)cpu_number) << VAPIC_CPU_SHIFT); (((hwaddr)cpu_number) << VAPIC_CPU_SHIFT);
cpu_physical_memory_rw(vapic_paddr + offsetof(VAPICState, enabled), cpu_physical_memory_rw(vapic_paddr + offsetof(VAPICState, enabled),
(void *)&enabled, sizeof(enabled), 1); (void *)&enabled, sizeof(enabled), 1);
apic_enable_vapic(env->apic_state, vapic_paddr); apic_enable_vapic(cpu->env.apic_state, vapic_paddr);
s->state = VAPIC_ACTIVE; s->state = VAPIC_ACTIVE;
return 0; return 0;
} }
static void patch_byte(CPUX86State *env, target_ulong addr, uint8_t byte) static void patch_byte(X86CPU *cpu, target_ulong addr, uint8_t byte)
{ {
cpu_memory_rw_debug(env, addr, &byte, 1, 1); cpu_memory_rw_debug(CPU(cpu), addr, &byte, 1, 1);
} }
static void patch_call(VAPICROMState *s, CPUX86State *env, target_ulong ip, static void patch_call(VAPICROMState *s, X86CPU *cpu, target_ulong ip,
uint32_t target) uint32_t target)
{ {
uint32_t offset; uint32_t offset;
offset = cpu_to_le32(target - ip - 5); offset = cpu_to_le32(target - ip - 5);
patch_byte(env, ip, 0xe8); /* call near */ patch_byte(cpu, ip, 0xe8); /* call near */
cpu_memory_rw_debug(env, ip + 1, (void *)&offset, sizeof(offset), 1); cpu_memory_rw_debug(CPU(cpu), ip + 1, (void *)&offset, sizeof(offset), 1);
} }
static void patch_instruction(VAPICROMState *s, X86CPU *cpu, target_ulong ip) static void patch_instruction(VAPICROMState *s, X86CPU *cpu, target_ulong ip)
@ -411,32 +413,32 @@ static void patch_instruction(VAPICROMState *s, X86CPU *cpu, target_ulong ip)
pause_all_vcpus(); pause_all_vcpus();
cpu_memory_rw_debug(env, ip, opcode, sizeof(opcode), 0); cpu_memory_rw_debug(cs, ip, opcode, sizeof(opcode), 0);
switch (opcode[0]) { switch (opcode[0]) {
case 0x89: /* mov r32 to r/m32 */ case 0x89: /* mov r32 to r/m32 */
patch_byte(env, ip, 0x50 + modrm_reg(opcode[1])); /* push reg */ patch_byte(cpu, ip, 0x50 + modrm_reg(opcode[1])); /* push reg */
patch_call(s, env, ip + 1, handlers->set_tpr); patch_call(s, cpu, ip + 1, handlers->set_tpr);
break; break;
case 0x8b: /* mov r/m32 to r32 */ case 0x8b: /* mov r/m32 to r32 */
patch_byte(env, ip, 0x90); patch_byte(cpu, ip, 0x90);
patch_call(s, env, ip + 1, handlers->get_tpr[modrm_reg(opcode[1])]); patch_call(s, cpu, ip + 1, handlers->get_tpr[modrm_reg(opcode[1])]);
break; break;
case 0xa1: /* mov abs to eax */ case 0xa1: /* mov abs to eax */
patch_call(s, env, ip, handlers->get_tpr[0]); patch_call(s, cpu, ip, handlers->get_tpr[0]);
break; break;
case 0xa3: /* mov eax to abs */ case 0xa3: /* mov eax to abs */
patch_call(s, env, ip, handlers->set_tpr_eax); patch_call(s, cpu, ip, handlers->set_tpr_eax);
break; break;
case 0xc7: /* mov imm32, r/m32 (c7/0) */ case 0xc7: /* mov imm32, r/m32 (c7/0) */
patch_byte(env, ip, 0x68); /* push imm32 */ patch_byte(cpu, ip, 0x68); /* push imm32 */
cpu_memory_rw_debug(env, ip + 6, (void *)&imm32, sizeof(imm32), 0); cpu_memory_rw_debug(cs, ip + 6, (void *)&imm32, sizeof(imm32), 0);
cpu_memory_rw_debug(env, ip + 1, (void *)&imm32, sizeof(imm32), 1); cpu_memory_rw_debug(cs, ip + 1, (void *)&imm32, sizeof(imm32), 1);
patch_call(s, env, ip + 5, handlers->set_tpr); patch_call(s, cpu, ip + 5, handlers->set_tpr);
break; break;
case 0xff: /* push r/m32 */ case 0xff: /* push r/m32 */
patch_byte(env, ip, 0x50); /* push eax */ patch_byte(cpu, ip, 0x50); /* push eax */
patch_call(s, env, ip + 1, handlers->get_tpr_stack); patch_call(s, cpu, ip + 1, handlers->get_tpr_stack);
break; break;
default: default:
abort(); abort();
@ -460,16 +462,16 @@ void vapic_report_tpr_access(DeviceState *dev, CPUState *cs, target_ulong ip,
cpu_synchronize_state(cs); cpu_synchronize_state(cs);
if (evaluate_tpr_instruction(s, env, &ip, access) < 0) { if (evaluate_tpr_instruction(s, cpu, &ip, access) < 0) {
if (s->state == VAPIC_ACTIVE) { if (s->state == VAPIC_ACTIVE) {
vapic_enable(s, env); vapic_enable(s, cpu);
} }
return; return;
} }
if (update_rom_mapping(s, env, ip) < 0) { if (update_rom_mapping(s, env, ip) < 0) {
return; return;
} }
if (vapic_enable(s, env) < 0) { if (vapic_enable(s, cpu) < 0) {
return; return;
} }
patch_instruction(s, cpu, ip); patch_instruction(s, cpu, ip);
@ -669,8 +671,8 @@ static void vapic_write(void *opaque, hwaddr addr, uint64_t data,
* accurate. * accurate.
*/ */
pause_all_vcpus(); pause_all_vcpus();
patch_byte(env, env->eip - 2, 0x66); patch_byte(cpu, env->eip - 2, 0x66);
patch_byte(env, env->eip - 1, 0x90); patch_byte(cpu, env->eip - 1, 0x90);
resume_all_vcpus(); resume_all_vcpus();
} }
@ -683,7 +685,7 @@ static void vapic_write(void *opaque, hwaddr addr, uint64_t data,
if (find_real_tpr_addr(s, env) < 0) { if (find_real_tpr_addr(s, env) < 0) {
break; break;
} }
vapic_enable(s, env); vapic_enable(s, cpu);
break; break;
default: default:
case 4: case 4:
@ -725,7 +727,7 @@ static void do_vapic_enable(void *data)
VAPICROMState *s = data; VAPICROMState *s = data;
X86CPU *cpu = X86_CPU(first_cpu); X86CPU *cpu = X86_CPU(first_cpu);
vapic_enable(s, &cpu->env); vapic_enable(s, cpu);
} }
static int vapic_post_load(void *opaque, int version_id) static int vapic_post_load(void *opaque, int version_id)

3
include/exec/cpu-all.h
View File

@ -22,6 +22,7 @@
#include "qemu-common.h" #include "qemu-common.h"
#include "exec/cpu-common.h" #include "exec/cpu-common.h"
#include "qemu/thread.h" #include "qemu/thread.h"
#include "qom/cpu.h"
/* some important defines: /* some important defines:
* *
@ -483,7 +484,7 @@ void qemu_mutex_lock_ramlist(void);
void qemu_mutex_unlock_ramlist(void); void qemu_mutex_unlock_ramlist(void);
#endif /* !CONFIG_USER_ONLY */ #endif /* !CONFIG_USER_ONLY */
int cpu_memory_rw_debug(CPUArchState *env, target_ulong addr, int cpu_memory_rw_debug(CPUState *cpu, target_ulong addr,
uint8_t *buf, int len, int is_write); uint8_t *buf, int len, int is_write);
#endif /* CPU_ALL_H */ #endif /* CPU_ALL_H */

18
include/exec/softmmu-semi.h
View File

@ -13,14 +13,14 @@ static inline uint32_t softmmu_tget32(CPUArchState *env, uint32_t addr)
{ {
uint32_t val; uint32_t val;
cpu_memory_rw_debug(env, addr, (uint8_t *)&val, 4, 0); cpu_memory_rw_debug(ENV_GET_CPU(env), addr, (uint8_t *)&val, 4, 0);
return tswap32(val); return tswap32(val);
} }
static inline uint32_t softmmu_tget8(CPUArchState *env, uint32_t addr) static inline uint32_t softmmu_tget8(CPUArchState *env, uint32_t addr)
{ {
uint8_t val; uint8_t val;
cpu_memory_rw_debug(env, addr, &val, 1, 0); cpu_memory_rw_debug(ENV_GET_CPU(env), addr, &val, 1, 0);
return val; return val;
} }
@ -31,7 +31,7 @@ static inline uint32_t softmmu_tget8(CPUArchState *env, uint32_t addr)
static inline void softmmu_tput32(CPUArchState *env, uint32_t addr, uint32_t val) static inline void softmmu_tput32(CPUArchState *env, uint32_t addr, uint32_t val)
{ {
val = tswap32(val); val = tswap32(val);
cpu_memory_rw_debug(env, addr, (uint8_t *)&val, 4, 1); cpu_memory_rw_debug(ENV_GET_CPU(env), addr, (uint8_t *)&val, 4, 1);
} }
#define put_user_u32(arg, p) ({ softmmu_tput32(env, p, arg) ; 0; }) #define put_user_u32(arg, p) ({ softmmu_tput32(env, p, arg) ; 0; })
#define put_user_ual(arg, p) put_user_u32(arg, p) #define put_user_ual(arg, p) put_user_u32(arg, p)
@ -42,8 +42,9 @@ static void *softmmu_lock_user(CPUArchState *env, uint32_t addr, uint32_t len,
uint8_t *p; uint8_t *p;
/* TODO: Make this something that isn't fixed size. */ /* TODO: Make this something that isn't fixed size. */
p = malloc(len); p = malloc(len);
if (p && copy) if (p && copy) {
cpu_memory_rw_debug(env, addr, p, len, 0); cpu_memory_rw_debug(ENV_GET_CPU(env), addr, p, len, 0);
}
return p; return p;
} }
#define lock_user(type, p, len, copy) softmmu_lock_user(env, p, len, copy) #define lock_user(type, p, len, copy) softmmu_lock_user(env, p, len, copy)
@ -58,7 +59,7 @@ static char *softmmu_lock_user_string(CPUArchState *env, uint32_t addr)
return NULL; return NULL;
} }
do { do {
cpu_memory_rw_debug(env, addr, &c, 1, 0); cpu_memory_rw_debug(ENV_GET_CPU(env), addr, &c, 1, 0);
addr++; addr++;
*(p++) = c; *(p++) = c;
} while (c); } while (c);
@ -68,8 +69,9 @@ static char *softmmu_lock_user_string(CPUArchState *env, uint32_t addr)
static void softmmu_unlock_user(CPUArchState *env, void *p, target_ulong addr, static void softmmu_unlock_user(CPUArchState *env, void *p, target_ulong addr,
target_ulong len) target_ulong len)
{ {
if (len) if (len) {
cpu_memory_rw_debug(env, addr, p, len, 1); cpu_memory_rw_debug(ENV_GET_CPU(env), addr, p, len, 1);
}
free(p); free(p);
} }
#define unlock_user(s, args, len) softmmu_unlock_user(env, s, args, len) #define unlock_user(s, args, len) softmmu_unlock_user(env, s, args, len)

2
monitor.c
View File

@ -1164,7 +1164,7 @@ static void memory_dump(Monitor *mon, int count, int format, int wsize,
cpu_physical_memory_read(addr, buf, l); cpu_physical_memory_read(addr, buf, l);
} else { } else {
env = mon_get_cpu(); env = mon_get_cpu();
if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) { if (cpu_memory_rw_debug(ENV_GET_CPU(env), addr, buf, l, 0) < 0) {
monitor_printf(mon, " Cannot access memory\n"); monitor_printf(mon, " Cannot access memory\n");
break; break;
} }

2
target-arm/arm-semi.c
View File

@ -161,7 +161,7 @@ static void arm_semi_flen_cb(CPUState *cs, target_ulong ret, target_ulong err)
/* The size is always stored in big-endian order, extract /* The size is always stored in big-endian order, extract
the value. We assume the size always fit in 32 bits. */ the value. We assume the size always fit in 32 bits. */
uint32_t size; uint32_t size;
cpu_memory_rw_debug(env, env->regs[13]-64+32, (uint8_t *)&size, 4, 0); cpu_memory_rw_debug(cs, env->regs[13]-64+32, (uint8_t *)&size, 4, 0);
env->regs[0] = be32_to_cpu(size); env->regs[0] = be32_to_cpu(size);
#ifdef CONFIG_USER_ONLY #ifdef CONFIG_USER_ONLY
((TaskState *)env->opaque)->swi_errno = err; ((TaskState *)env->opaque)->swi_errno = err;

8
target-i386/helper.c
View File

@ -363,7 +363,7 @@ void x86_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf,
cpu_fprintf(f, "Code="); cpu_fprintf(f, "Code=");
for (i = 0; i < DUMP_CODE_BYTES_TOTAL; i++) { for (i = 0; i < DUMP_CODE_BYTES_TOTAL; i++) {
if (cpu_memory_rw_debug(env, base - offs + i, &code, 1, 0) == 0) { if (cpu_memory_rw_debug(cs, base - offs + i, &code, 1, 0) == 0) {
snprintf(codestr, sizeof(codestr), "%02x", code); snprintf(codestr, sizeof(codestr), "%02x", code);
} else { } else {
snprintf(codestr, sizeof(codestr), "??"); snprintf(codestr, sizeof(codestr), "??");
@ -1260,6 +1260,8 @@ int cpu_x86_get_descr_debug(CPUX86State *env, unsigned int selector,
target_ulong *base, unsigned int *limit, target_ulong *base, unsigned int *limit,
unsigned int *flags) unsigned int *flags)
{ {
X86CPU *cpu = x86_env_get_cpu(env);
CPUState *cs = CPU(cpu);
SegmentCache *dt; SegmentCache *dt;
target_ulong ptr; target_ulong ptr;
uint32_t e1, e2; uint32_t e1, e2;
@ -1272,8 +1274,8 @@ int cpu_x86_get_descr_debug(CPUX86State *env, unsigned int selector,
index = selector & ~7; index = selector & ~7;
ptr = dt->base + index; ptr = dt->base + index;
if ((index + 7) > dt->limit if ((index + 7) > dt->limit
|| cpu_memory_rw_debug(env, ptr, (uint8_t *)&e1, sizeof(e1), 0) != 0 || cpu_memory_rw_debug(cs, ptr, (uint8_t *)&e1, sizeof(e1), 0) != 0
|| cpu_memory_rw_debug(env, ptr+4, (uint8_t *)&e2, sizeof(e2), 0) != 0) || cpu_memory_rw_debug(cs, ptr+4, (uint8_t *)&e2, sizeof(e2), 0) != 0)
return 0; return 0;
*base = ((e1 >> 16) | ((e2 & 0xff) << 16) | (e2 & 0xff000000)); *base = ((e1 >> 16) | ((e2 & 0xff) << 16) | (e2 & 0xff000000));

14
target-i386/kvm.c
View File

@ -1932,25 +1932,23 @@ static int kvm_handle_tpr_access(X86CPU *cpu)
return 1; return 1;
} }
int kvm_arch_insert_sw_breakpoint(CPUState *cpu, struct kvm_sw_breakpoint *bp) int kvm_arch_insert_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint *bp)
{ {
CPUX86State *env = &X86_CPU(cpu)->env;
static const uint8_t int3 = 0xcc; static const uint8_t int3 = 0xcc;
if (cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 1, 0) || if (cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)&bp->saved_insn, 1, 0) ||
cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&int3, 1, 1)) { cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)&int3, 1, 1)) {
return -EINVAL; return -EINVAL;
} }
return 0; return 0;
} }
int kvm_arch_remove_sw_breakpoint(CPUState *cpu, struct kvm_sw_breakpoint *bp) int kvm_arch_remove_sw_breakpoint(CPUState *cs, struct kvm_sw_breakpoint *bp)
{ {
CPUX86State *env = &X86_CPU(cpu)->env;
uint8_t int3; uint8_t int3;
if (cpu_memory_rw_debug(env, bp->pc, &int3, 1, 0) || int3 != 0xcc || if (cpu_memory_rw_debug(cs, bp->pc, &int3, 1, 0) || int3 != 0xcc ||
cpu_memory_rw_debug(env, bp->pc, (uint8_t *)&bp->saved_insn, 1, 1)) { cpu_memory_rw_debug(cs, bp->pc, (uint8_t *)&bp->saved_insn, 1, 1)) {
return -EINVAL; return -EINVAL;
} }
return 0; return 0;

5
target-sparc/mmu_helper.c
View File

@ -356,6 +356,7 @@ void dump_mmu(FILE *f, fprintf_function cpu_fprintf, CPUSPARCState *env)
int target_memory_rw_debug(CPUSPARCState *env, target_ulong addr, int target_memory_rw_debug(CPUSPARCState *env, target_ulong addr,
uint8_t *buf, int len, int is_write) uint8_t *buf, int len, int is_write)
{ {
CPUState *cs = CPU(sparc_env_get_cpu(env));
int i; int i;
int len1; int len1;
int cwp = env->cwp; int cwp = env->cwp;
@ -390,7 +391,7 @@ int target_memory_rw_debug(CPUSPARCState *env, target_ulong addr,
/* Handle access before this window. */ /* Handle access before this window. */
if (addr < fp) { if (addr < fp) {
len1 = fp - addr; len1 = fp - addr;
if (cpu_memory_rw_debug(env, addr, buf, len1, is_write) != 0) { if (cpu_memory_rw_debug(cs, addr, buf, len1, is_write) != 0) {
return -1; return -1;
} }
addr += len1; addr += len1;
@ -426,7 +427,7 @@ int target_memory_rw_debug(CPUSPARCState *env, target_ulong addr,
} }
} }
} }
return cpu_memory_rw_debug(env, addr, buf, len, is_write); return cpu_memory_rw_debug(cs, addr, buf, len, is_write);
} }
#else /* !TARGET_SPARC64 */ #else /* !TARGET_SPARC64 */

10
target-xtensa/xtensa-semi.c
View File

@ -204,8 +204,8 @@ void HELPER(simcall)(CPUXtensaState *env)
int i; int i;
for (i = 0; i < ARRAY_SIZE(name); ++i) { for (i = 0; i < ARRAY_SIZE(name); ++i) {
rc = cpu_memory_rw_debug( rc = cpu_memory_rw_debug(cs, regs[3] + i,
env, regs[3] + i, (uint8_t *)name + i, 1, 0); (uint8_t *)name + i, 1, 0);
if (rc != 0 || name[i] == 0) { if (rc != 0 || name[i] == 0) {
break; break;
} }
@ -249,7 +249,7 @@ void HELPER(simcall)(CPUXtensaState *env)
FD_SET(fd, &fdset); FD_SET(fd, &fdset);
if (target_tv) { if (target_tv) {
cpu_memory_rw_debug(env, target_tv, cpu_memory_rw_debug(cs, target_tv,
(uint8_t *)target_tvv, sizeof(target_tvv), 0); (uint8_t *)target_tvv, sizeof(target_tvv), 0);
tv.tv_sec = (int32_t)tswap32(target_tvv[0]); tv.tv_sec = (int32_t)tswap32(target_tvv[0]);
tv.tv_usec = (int32_t)tswap32(target_tvv[1]); tv.tv_usec = (int32_t)tswap32(target_tvv[1]);
@ -284,8 +284,8 @@ void HELPER(simcall)(CPUXtensaState *env)
}; };
argv.argptr[0] = tswap32(regs[3] + offsetof(struct Argv, text)); argv.argptr[0] = tswap32(regs[3] + offsetof(struct Argv, text));
cpu_memory_rw_debug( cpu_memory_rw_debug(cs,
env, regs[3], (uint8_t *)&argv, sizeof(argv), 1); regs[3], (uint8_t *)&argv, sizeof(argv), 1);
} }
break; break;