clean CPUState
This commit is contained in:
Nguyen Anh Quynh
parent
07958cd846
commit
6b457f23ba
27
qemu/exec.c
27
qemu/exec.c
@ -634,33 +634,6 @@ void cpu_single_step(CPUState *cpu, int enabled)
|
|||||||
|
|
||||||
void cpu_abort(CPUState *cpu, const char *fmt, ...)
|
void cpu_abort(CPUState *cpu, const char *fmt, ...)
|
||||||
{
|
{
|
||||||
va_list ap;
|
|
||||||
va_list ap2;
|
|
||||||
|
|
||||||
va_start(ap, fmt);
|
|
||||||
va_copy(ap2, ap);
|
|
||||||
fprintf(stderr, "qemu: fatal: ");
|
|
||||||
vfprintf(stderr, fmt, ap);
|
|
||||||
fprintf(stderr, "\n");
|
|
||||||
cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_FPU | CPU_DUMP_CCOP);
|
|
||||||
if (qemu_log_enabled()) {
|
|
||||||
qemu_log("qemu: fatal: ");
|
|
||||||
qemu_log_vprintf(fmt, ap2);
|
|
||||||
qemu_log("\n");
|
|
||||||
log_cpu_state(cpu, CPU_DUMP_FPU | CPU_DUMP_CCOP);
|
|
||||||
qemu_log_flush();
|
|
||||||
qemu_log_close();
|
|
||||||
}
|
|
||||||
va_end(ap2);
|
|
||||||
va_end(ap);
|
|
||||||
#if defined(CONFIG_USER_ONLY)
|
|
||||||
{
|
|
||||||
struct sigaction act;
|
|
||||||
sigfillset(&act.sa_mask);
|
|
||||||
act.sa_handler = SIG_DFL;
|
|
||||||
sigaction(SIGABRT, &act, NULL);
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
abort();
|
abort();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@ -67,7 +67,6 @@ void GCC_FMT_ATTR(2, 3) qemu_log_mask(int mask, const char *fmt, ...);
|
|||||||
|
|
||||||
/* Special cases: */
|
/* Special cases: */
|
||||||
|
|
||||||
/* cpu_dump_state() logging functions: */
|
|
||||||
/**
|
/**
|
||||||
* log_cpu_state:
|
* log_cpu_state:
|
||||||
* @cpu: The CPU whose state is to be logged.
|
* @cpu: The CPU whose state is to be logged.
|
||||||
@ -77,9 +76,6 @@ void GCC_FMT_ATTR(2, 3) qemu_log_mask(int mask, const char *fmt, ...);
|
|||||||
*/
|
*/
|
||||||
static inline void log_cpu_state(CPUState *cpu, int flags)
|
static inline void log_cpu_state(CPUState *cpu, int flags)
|
||||||
{
|
{
|
||||||
if (qemu_log_enabled()) {
|
|
||||||
cpu_dump_state(cpu, qemu_logfile, fprintf, flags);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
|||||||
@ -80,8 +80,6 @@ struct TranslationBlock;
|
|||||||
* @do_unaligned_access: Callback for unaligned access handling, if
|
* @do_unaligned_access: Callback for unaligned access handling, if
|
||||||
* the target defines #ALIGNED_ONLY.
|
* the target defines #ALIGNED_ONLY.
|
||||||
* @memory_rw_debug: Callback for GDB memory access.
|
* @memory_rw_debug: Callback for GDB memory access.
|
||||||
* @dump_state: Callback for dumping state.
|
|
||||||
* @dump_statistics: Callback for dumping statistics.
|
|
||||||
* @get_arch_id: Callback for getting architecture-dependent CPU ID.
|
* @get_arch_id: Callback for getting architecture-dependent CPU ID.
|
||||||
* @get_paging_enabled: Callback for inquiring whether paging is enabled.
|
* @get_paging_enabled: Callback for inquiring whether paging is enabled.
|
||||||
* @get_memory_mapping: Callback for obtaining the memory mappings.
|
* @get_memory_mapping: Callback for obtaining the memory mappings.
|
||||||
@ -110,10 +108,6 @@ typedef struct CPUClass {
|
|||||||
int is_write, int is_user, uintptr_t retaddr);
|
int is_write, int is_user, uintptr_t retaddr);
|
||||||
int (*memory_rw_debug)(CPUState *cpu, vaddr addr,
|
int (*memory_rw_debug)(CPUState *cpu, vaddr addr,
|
||||||
uint8_t *buf, int len, bool is_write);
|
uint8_t *buf, int len, bool is_write);
|
||||||
void (*dump_state)(CPUState *cpu, FILE *f, fprintf_function cpu_fprintf,
|
|
||||||
int flags);
|
|
||||||
void (*dump_statistics)(CPUState *cpu, FILE *f,
|
|
||||||
fprintf_function cpu_fprintf, int flags);
|
|
||||||
int64_t (*get_arch_id)(CPUState *cpu);
|
int64_t (*get_arch_id)(CPUState *cpu);
|
||||||
bool (*get_paging_enabled)(const CPUState *cpu);
|
bool (*get_paging_enabled)(const CPUState *cpu);
|
||||||
void (*get_memory_mapping)(CPUState *cpu, MemoryMappingList *list);
|
void (*get_memory_mapping)(CPUState *cpu, MemoryMappingList *list);
|
||||||
@ -124,8 +118,6 @@ typedef struct CPUClass {
|
|||||||
hwaddr (*get_phys_page_debug)(CPUState *cpu, vaddr addr);
|
hwaddr (*get_phys_page_debug)(CPUState *cpu, vaddr addr);
|
||||||
void (*debug_excp_handler)(CPUState *cpu);
|
void (*debug_excp_handler)(CPUState *cpu);
|
||||||
|
|
||||||
const struct VMStateDescription *vmsd;
|
|
||||||
|
|
||||||
void (*cpu_exec_enter)(CPUState *cpu);
|
void (*cpu_exec_enter)(CPUState *cpu);
|
||||||
void (*cpu_exec_exit)(CPUState *cpu);
|
void (*cpu_exec_exit)(CPUState *cpu);
|
||||||
bool (*cpu_exec_interrupt)(CPUState *cpu, int interrupt_request);
|
bool (*cpu_exec_interrupt)(CPUState *cpu, int interrupt_request);
|
||||||
@ -296,30 +288,6 @@ enum CPUDumpFlags {
|
|||||||
CPU_DUMP_CCOP = 0x00040000,
|
CPU_DUMP_CCOP = 0x00040000,
|
||||||
};
|
};
|
||||||
|
|
||||||
/**
|
|
||||||
* cpu_dump_state:
|
|
||||||
* @cpu: The CPU whose state is to be dumped.
|
|
||||||
* @f: File to dump to.
|
|
||||||
* @cpu_fprintf: Function to dump with.
|
|
||||||
* @flags: Flags what to dump.
|
|
||||||
*
|
|
||||||
* Dumps CPU state.
|
|
||||||
*/
|
|
||||||
void cpu_dump_state(CPUState *cpu, FILE *f, fprintf_function cpu_fprintf,
|
|
||||||
int flags);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* cpu_dump_statistics:
|
|
||||||
* @cpu: The CPU whose state is to be dumped.
|
|
||||||
* @f: File to dump to.
|
|
||||||
* @cpu_fprintf: Function to dump with.
|
|
||||||
* @flags: Flags what to dump.
|
|
||||||
*
|
|
||||||
* Dumps CPU statistics.
|
|
||||||
*/
|
|
||||||
void cpu_dump_statistics(CPUState *cpu, FILE *f, fprintf_function cpu_fprintf,
|
|
||||||
int flags);
|
|
||||||
|
|
||||||
#ifndef CONFIG_USER_ONLY
|
#ifndef CONFIG_USER_ONLY
|
||||||
/**
|
/**
|
||||||
* cpu_get_phys_page_debug:
|
* cpu_get_phys_page_debug:
|
||||||
|
|||||||
@ -67,26 +67,6 @@ static bool cpu_common_exec_interrupt(CPUState *cpu, int int_req)
|
|||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
void cpu_dump_state(CPUState *cpu, FILE *f, fprintf_function cpu_fprintf,
|
|
||||||
int flags)
|
|
||||||
{
|
|
||||||
CPUClass *cc = CPU_GET_CLASS(cpu->uc, cpu);
|
|
||||||
|
|
||||||
if (cc->dump_state) {
|
|
||||||
cc->dump_state(cpu, f, cpu_fprintf, flags);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void cpu_dump_statistics(CPUState *cpu, FILE *f, fprintf_function cpu_fprintf,
|
|
||||||
int flags)
|
|
||||||
{
|
|
||||||
CPUClass *cc = CPU_GET_CLASS(cpu->uc, cpu);
|
|
||||||
|
|
||||||
if (cc->dump_statistics) {
|
|
||||||
cc->dump_statistics(cpu, f, cpu_fprintf, flags);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void cpu_reset(CPUState *cpu)
|
void cpu_reset(CPUState *cpu)
|
||||||
{
|
{
|
||||||
CPUClass *klass = CPU_GET_CLASS(cpu->uc, cpu);
|
CPUClass *klass = CPU_GET_CLASS(cpu->uc, cpu);
|
||||||
|
|||||||
@ -176,10 +176,6 @@ static inline ARMCPU *arm_env_get_cpu(CPUARMState *env)
|
|||||||
|
|
||||||
#define ENV_OFFSET offsetof(ARMCPU, env)
|
#define ENV_OFFSET offsetof(ARMCPU, env)
|
||||||
|
|
||||||
#ifndef CONFIG_USER_ONLY
|
|
||||||
extern const struct VMStateDescription vmstate_arm_cpu;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
void register_cp_regs_for_features(ARMCPU *cpu);
|
void register_cp_regs_for_features(ARMCPU *cpu);
|
||||||
void init_cpreg_list(ARMCPU *cpu);
|
void init_cpreg_list(ARMCPU *cpu);
|
||||||
|
|
||||||
@ -189,17 +185,11 @@ bool arm_cpu_exec_interrupt(CPUState *cpu, int int_req);
|
|||||||
|
|
||||||
hwaddr arm_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr);
|
hwaddr arm_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr);
|
||||||
|
|
||||||
int arm_cpu_gdb_read_register(CPUState *cpu, uint8_t *buf, int reg);
|
|
||||||
int arm_cpu_gdb_write_register(CPUState *cpu, uint8_t *buf, int reg);
|
|
||||||
|
|
||||||
/* Callback functions for the generic timer's timers. */
|
/* Callback functions for the generic timer's timers. */
|
||||||
void arm_gt_ptimer_cb(void *opaque);
|
void arm_gt_ptimer_cb(void *opaque);
|
||||||
void arm_gt_vtimer_cb(void *opaque);
|
void arm_gt_vtimer_cb(void *opaque);
|
||||||
|
|
||||||
#ifdef TARGET_AARCH64
|
#ifdef TARGET_AARCH64
|
||||||
int aarch64_cpu_gdb_read_register(CPUState *cpu, uint8_t *buf, int reg);
|
|
||||||
int aarch64_cpu_gdb_write_register(CPUState *cpu, uint8_t *buf, int reg);
|
|
||||||
|
|
||||||
void aarch64_cpu_do_interrupt(CPUState *cs);
|
void aarch64_cpu_do_interrupt(CPUState *cs);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
|||||||
@ -1004,7 +1004,6 @@ static void arm_cpu_class_init(struct uc_struct *uc, CPUClass *oc, void *data)
|
|||||||
|
|
||||||
cc->has_work = arm_cpu_has_work;
|
cc->has_work = arm_cpu_has_work;
|
||||||
cc->cpu_exec_interrupt = arm_cpu_exec_interrupt;
|
cc->cpu_exec_interrupt = arm_cpu_exec_interrupt;
|
||||||
//cc->dump_state = arm_cpu_dump_state;
|
|
||||||
cc->set_pc = arm_cpu_set_pc;
|
cc->set_pc = arm_cpu_set_pc;
|
||||||
#ifdef CONFIG_USER_ONLY
|
#ifdef CONFIG_USER_ONLY
|
||||||
cc->handle_mmu_fault = arm_cpu_handle_mmu_fault;
|
cc->handle_mmu_fault = arm_cpu_handle_mmu_fault;
|
||||||
|
|||||||
@ -114,51 +114,6 @@ void a64_translate_init(struct uc_struct *uc)
|
|||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
#if 0
|
|
||||||
void aarch64_cpu_dump_state(CPUState *cs, FILE *f,
|
|
||||||
fprintf_function cpu_fprintf, int flags)
|
|
||||||
{
|
|
||||||
ARMCPU *cpu = ARM_CPU(cs);
|
|
||||||
CPUARMState *env = &cpu->env;
|
|
||||||
uint32_t psr = pstate_read(env);
|
|
||||||
int i;
|
|
||||||
|
|
||||||
cpu_fprintf(f, "PC=%016"PRIx64" SP=%016"PRIx64"\n",
|
|
||||||
env->pc, env->xregs[31]);
|
|
||||||
for (i = 0; i < 31; i++) {
|
|
||||||
cpu_fprintf(f, "X%02d=%016"PRIx64, i, env->xregs[i]);
|
|
||||||
if ((i % 4) == 3) {
|
|
||||||
cpu_fprintf(f, "\n");
|
|
||||||
} else {
|
|
||||||
cpu_fprintf(f, " ");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
cpu_fprintf(f, "PSTATE=%08x (flags %c%c%c%c)\n",
|
|
||||||
psr,
|
|
||||||
psr & PSTATE_N ? 'N' : '-',
|
|
||||||
psr & PSTATE_Z ? 'Z' : '-',
|
|
||||||
psr & PSTATE_C ? 'C' : '-',
|
|
||||||
psr & PSTATE_V ? 'V' : '-');
|
|
||||||
cpu_fprintf(f, "\n");
|
|
||||||
|
|
||||||
if (flags & CPU_DUMP_FPU) {
|
|
||||||
int numvfpregs = 32;
|
|
||||||
for (i = 0; i < numvfpregs; i += 2) {
|
|
||||||
uint64_t vlo = float64_val(env->vfp.regs[i * 2]);
|
|
||||||
uint64_t vhi = float64_val(env->vfp.regs[(i * 2) + 1]);
|
|
||||||
cpu_fprintf(f, "q%02d=%016" PRIx64 ":%016" PRIx64 " ",
|
|
||||||
i, vhi, vlo);
|
|
||||||
vlo = float64_val(env->vfp.regs[(i + 1) * 2]);
|
|
||||||
vhi = float64_val(env->vfp.regs[((i + 1) * 2) + 1]);
|
|
||||||
cpu_fprintf(f, "q%02d=%016" PRIx64 ":%016" PRIx64 "\n",
|
|
||||||
i + 1, vhi, vlo);
|
|
||||||
}
|
|
||||||
cpu_fprintf(f, "FPCR: %08x FPSR: %08x\n",
|
|
||||||
vfp_get_fpcr(env), vfp_get_fpsr(env));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
void gen_a64_set_pc_im(DisasContext *s, uint64_t val)
|
void gen_a64_set_pc_im(DisasContext *s, uint64_t val)
|
||||||
{
|
{
|
||||||
TCGContext *tcg_ctx = s->uc->tcg_ctx;
|
TCGContext *tcg_ctx = s->uc->tcg_ctx;
|
||||||
|
|||||||
@ -11564,62 +11564,6 @@ void gen_intermediate_code_pc(CPUARMState *env, TranslationBlock *tb)
|
|||||||
gen_intermediate_code_internal(arm_env_get_cpu(env), tb, true);
|
gen_intermediate_code_internal(arm_env_get_cpu(env), tb, true);
|
||||||
}
|
}
|
||||||
|
|
||||||
#if 0
|
|
||||||
static const char *cpu_mode_names[16] = {
|
|
||||||
"usr", "fiq", "irq", "svc", "???", "???", "mon", "abt",
|
|
||||||
"???", "???", "hyp", "und", "???", "???", "???", "sys"
|
|
||||||
};
|
|
||||||
|
|
||||||
void arm_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf,
|
|
||||||
int flags)
|
|
||||||
{
|
|
||||||
ARMCPU *cpu = ARM_CPU(cs);
|
|
||||||
CPUARMState *env = &cpu->env;
|
|
||||||
int i;
|
|
||||||
uint32_t psr;
|
|
||||||
|
|
||||||
if (is_a64(env)) {
|
|
||||||
aarch64_cpu_dump_state(cs, f, cpu_fprintf, flags);
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
for(i=0;i<16;i++) {
|
|
||||||
cpu_fprintf(f, "R%02d=%08x", i, env->regs[i]);
|
|
||||||
if ((i % 4) == 3)
|
|
||||||
cpu_fprintf(f, "\n");
|
|
||||||
else
|
|
||||||
cpu_fprintf(f, " ");
|
|
||||||
}
|
|
||||||
psr = cpsr_read(env);
|
|
||||||
cpu_fprintf(f, "PSR=%08x %c%c%c%c %c %s%d\n",
|
|
||||||
psr,
|
|
||||||
psr & (1 << 31) ? 'N' : '-',
|
|
||||||
psr & (1 << 30) ? 'Z' : '-',
|
|
||||||
psr & (1 << 29) ? 'C' : '-',
|
|
||||||
psr & (1 << 28) ? 'V' : '-',
|
|
||||||
psr & CPSR_T ? 'T' : 'A',
|
|
||||||
cpu_mode_names[psr & 0xf], (psr & 0x10) ? 32 : 26);
|
|
||||||
|
|
||||||
if (flags & CPU_DUMP_FPU) {
|
|
||||||
int numvfpregs = 0;
|
|
||||||
if (arm_feature(env, ARM_FEATURE_VFP)) {
|
|
||||||
numvfpregs += 16;
|
|
||||||
}
|
|
||||||
if (arm_feature(env, ARM_FEATURE_VFP3)) {
|
|
||||||
numvfpregs += 16;
|
|
||||||
}
|
|
||||||
for (i = 0; i < numvfpregs; i++) {
|
|
||||||
uint64_t v = float64_val(env->vfp.regs[i]);
|
|
||||||
cpu_fprintf(f, "s%02d=%08x s%02d=%08x d%02d=%016" PRIx64 "\n",
|
|
||||||
i * 2, (uint32_t)v,
|
|
||||||
i * 2 + 1, (uint32_t)(v >> 32),
|
|
||||||
i, v);
|
|
||||||
}
|
|
||||||
cpu_fprintf(f, "FPSCR: %08x\n", (int)env->vfp.xregs[ARM_VFP_FPSCR]);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
void restore_state_to_opc(CPUARMState *env, TranslationBlock *tb, int pc_pos)
|
void restore_state_to_opc(CPUARMState *env, TranslationBlock *tb, int pc_pos)
|
||||||
{
|
{
|
||||||
TCGContext *tcg_ctx = env->uc->tcg_ctx;
|
TCGContext *tcg_ctx = env->uc->tcg_ctx;
|
||||||
|
|||||||
@ -35,7 +35,6 @@ typedef struct X86CPUDefinition X86CPUDefinition;
|
|||||||
/**
|
/**
|
||||||
* X86CPUClass:
|
* X86CPUClass:
|
||||||
* @cpu_def: CPU model definition
|
* @cpu_def: CPU model definition
|
||||||
* @kvm_required: Whether CPU model requires KVM to be enabled.
|
|
||||||
* @parent_realize: The parent class' realize handler.
|
* @parent_realize: The parent class' realize handler.
|
||||||
* @parent_reset: The parent class' reset handler.
|
* @parent_reset: The parent class' reset handler.
|
||||||
*
|
*
|
||||||
@ -49,8 +48,6 @@ typedef struct X86CPUClass {
|
|||||||
/* Should be eventually replaced by subclass-specific property defaults. */
|
/* Should be eventually replaced by subclass-specific property defaults. */
|
||||||
X86CPUDefinition *cpu_def;
|
X86CPUDefinition *cpu_def;
|
||||||
|
|
||||||
bool kvm_required;
|
|
||||||
|
|
||||||
void (*parent_reset)(CPUState *cpu);
|
void (*parent_reset)(CPUState *cpu);
|
||||||
} X86CPUClass;
|
} X86CPUClass;
|
||||||
|
|
||||||
@ -76,8 +73,6 @@ typedef struct X86CPU {
|
|||||||
bool hyperv_time;
|
bool hyperv_time;
|
||||||
bool check_cpuid;
|
bool check_cpuid;
|
||||||
bool enforce_cpuid;
|
bool enforce_cpuid;
|
||||||
bool expose_kvm;
|
|
||||||
bool migratable;
|
|
||||||
bool host_features;
|
bool host_features;
|
||||||
|
|
||||||
/* if true the CPUID code directly forward host cache leaves to the guest */
|
/* if true the CPUID code directly forward host cache leaves to the guest */
|
||||||
@ -93,11 +88,6 @@ typedef struct X86CPU {
|
|||||||
*/
|
*/
|
||||||
bool enable_pmu;
|
bool enable_pmu;
|
||||||
|
|
||||||
/* in order to simplify APIC support, we leave this pointer to the
|
|
||||||
user */
|
|
||||||
/* APICCommonState *apic_state; */
|
|
||||||
void *apic_state;
|
|
||||||
|
|
||||||
struct X86CPUClass cc;
|
struct X86CPUClass cc;
|
||||||
} X86CPU;
|
} X86CPU;
|
||||||
|
|
||||||
@ -114,10 +104,6 @@ static inline X86CPU *x86_env_get_cpu(CPUX86State *env)
|
|||||||
|
|
||||||
#define ENV_OFFSET offsetof(X86CPU, env)
|
#define ENV_OFFSET offsetof(X86CPU, env)
|
||||||
|
|
||||||
#ifndef CONFIG_USER_ONLY
|
|
||||||
extern struct VMStateDescription vmstate_x86_cpu;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* x86_cpu_do_interrupt:
|
* x86_cpu_do_interrupt:
|
||||||
* @cpu: vCPU the interrupt is to be handled by.
|
* @cpu: vCPU the interrupt is to be handled by.
|
||||||
@ -127,14 +113,8 @@ bool x86_cpu_exec_interrupt(CPUState *cpu, int int_req);
|
|||||||
|
|
||||||
void x86_cpu_get_memory_mapping(CPUState *cpu, MemoryMappingList *list);
|
void x86_cpu_get_memory_mapping(CPUState *cpu, MemoryMappingList *list);
|
||||||
|
|
||||||
void x86_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf,
|
|
||||||
int flags);
|
|
||||||
|
|
||||||
hwaddr x86_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr);
|
hwaddr x86_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr);
|
||||||
|
|
||||||
int x86_cpu_gdb_read_register(CPUState *cpu, uint8_t *buf, int reg);
|
|
||||||
int x86_cpu_gdb_write_register(CPUState *cpu, uint8_t *buf, int reg);
|
|
||||||
|
|
||||||
void x86_cpu_exec_enter(CPUState *cpu);
|
void x86_cpu_exec_enter(CPUState *cpu);
|
||||||
void x86_cpu_exec_exit(CPUState *cpu);
|
void x86_cpu_exec_exit(CPUState *cpu);
|
||||||
|
|
||||||
|
|||||||
@ -1941,7 +1941,6 @@ static void x86_cpu_common_class_init(struct uc_struct *uc, CPUClass *oc, void *
|
|||||||
cc->has_work = x86_cpu_has_work;
|
cc->has_work = x86_cpu_has_work;
|
||||||
cc->do_interrupt = x86_cpu_do_interrupt;
|
cc->do_interrupt = x86_cpu_do_interrupt;
|
||||||
cc->cpu_exec_interrupt = x86_cpu_exec_interrupt;
|
cc->cpu_exec_interrupt = x86_cpu_exec_interrupt;
|
||||||
cc->dump_state = x86_cpu_dump_state;
|
|
||||||
cc->set_pc = x86_cpu_set_pc;
|
cc->set_pc = x86_cpu_set_pc;
|
||||||
cc->synchronize_from_tb = x86_cpu_synchronize_from_tb;
|
cc->synchronize_from_tb = x86_cpu_synchronize_from_tb;
|
||||||
cc->get_arch_id = x86_cpu_get_arch_id;
|
cc->get_arch_id = x86_cpu_get_arch_id;
|
||||||
|
|||||||
@ -1357,10 +1357,6 @@ void cpu_report_tpr_access(CPUX86State *env, TPRAccess access);
|
|||||||
void x86_cpu_compat_set_features(const char *cpu_model, FeatureWord w,
|
void x86_cpu_compat_set_features(const char *cpu_model, FeatureWord w,
|
||||||
uint32_t feat_add, uint32_t feat_remove);
|
uint32_t feat_add, uint32_t feat_remove);
|
||||||
|
|
||||||
void x86_cpu_compat_kvm_no_autoenable(FeatureWord w, uint32_t features);
|
|
||||||
void x86_cpu_compat_kvm_no_autodisable(FeatureWord w, uint32_t features);
|
|
||||||
|
|
||||||
|
|
||||||
/* Return name of 32-bit register, from a R_* constant */
|
/* Return name of 32-bit register, from a R_* constant */
|
||||||
const char *get_register_name_32(unsigned int reg);
|
const char *get_register_name_32(unsigned int reg);
|
||||||
|
|
||||||
|
|||||||
@ -176,203 +176,6 @@ done:
|
|||||||
cpu_fprintf(f, "\n");
|
cpu_fprintf(f, "\n");
|
||||||
}
|
}
|
||||||
|
|
||||||
#define DUMP_CODE_BYTES_TOTAL 50
|
|
||||||
#define DUMP_CODE_BYTES_BACKWARD 20
|
|
||||||
|
|
||||||
void x86_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf,
|
|
||||||
int flags)
|
|
||||||
{
|
|
||||||
X86CPU *cpu = X86_CPU(cs->uc, cs);
|
|
||||||
CPUX86State *env = &cpu->env;
|
|
||||||
int eflags, i, nb;
|
|
||||||
char cc_op_name[32];
|
|
||||||
static const char *seg_name[6] = { "ES", "CS", "SS", "DS", "FS", "GS" };
|
|
||||||
|
|
||||||
eflags = cpu_compute_eflags(env);
|
|
||||||
#ifdef TARGET_X86_64
|
|
||||||
if (env->hflags & HF_CS64_MASK) {
|
|
||||||
cpu_fprintf(f,
|
|
||||||
"RAX=%016" PRIx64 " RBX=%016" PRIx64 " RCX=%016" PRIx64 " RDX=%016" PRIx64 "\n"
|
|
||||||
"RSI=%016" PRIx64 " RDI=%016" PRIx64 " RBP=%016" PRIx64 " RSP=%016" PRIx64 "\n"
|
|
||||||
"R8 =%016" PRIx64 " R9 =%016" PRIx64 " R10=%016" PRIx64 " R11=%016" PRIx64 "\n"
|
|
||||||
"R12=%016" PRIx64 " R13=%016" PRIx64 " R14=%016" PRIx64 " R15=%016" PRIx64 "\n"
|
|
||||||
"RIP=%016" PRIx64 " RFL=%08x [%c%c%c%c%c%c%c] CPL=%d II=%d A20=%d SMM=%d HLT=%d\n",
|
|
||||||
env->regs[R_EAX],
|
|
||||||
env->regs[R_EBX],
|
|
||||||
env->regs[R_ECX],
|
|
||||||
env->regs[R_EDX],
|
|
||||||
env->regs[R_ESI],
|
|
||||||
env->regs[R_EDI],
|
|
||||||
env->regs[R_EBP],
|
|
||||||
env->regs[R_ESP],
|
|
||||||
env->regs[8],
|
|
||||||
env->regs[9],
|
|
||||||
env->regs[10],
|
|
||||||
env->regs[11],
|
|
||||||
env->regs[12],
|
|
||||||
env->regs[13],
|
|
||||||
env->regs[14],
|
|
||||||
env->regs[15],
|
|
||||||
env->eip, eflags,
|
|
||||||
eflags & DF_MASK ? 'D' : '-',
|
|
||||||
eflags & CC_O ? 'O' : '-',
|
|
||||||
eflags & CC_S ? 'S' : '-',
|
|
||||||
eflags & CC_Z ? 'Z' : '-',
|
|
||||||
eflags & CC_A ? 'A' : '-',
|
|
||||||
eflags & CC_P ? 'P' : '-',
|
|
||||||
eflags & CC_C ? 'C' : '-',
|
|
||||||
env->hflags & HF_CPL_MASK,
|
|
||||||
(env->hflags >> HF_INHIBIT_IRQ_SHIFT) & 1,
|
|
||||||
(env->a20_mask >> 20) & 1,
|
|
||||||
(env->hflags >> HF_SMM_SHIFT) & 1,
|
|
||||||
cs->halted);
|
|
||||||
} else
|
|
||||||
#endif
|
|
||||||
{
|
|
||||||
cpu_fprintf(f, "EAX=%08x EBX=%08x ECX=%08x EDX=%08x\n"
|
|
||||||
"ESI=%08x EDI=%08x EBP=%08x ESP=%08x\n"
|
|
||||||
"EIP=%08x EFL=%08x [%c%c%c%c%c%c%c] CPL=%d II=%d A20=%d SMM=%d HLT=%d\n",
|
|
||||||
(uint32_t)env->regs[R_EAX],
|
|
||||||
(uint32_t)env->regs[R_EBX],
|
|
||||||
(uint32_t)env->regs[R_ECX],
|
|
||||||
(uint32_t)env->regs[R_EDX],
|
|
||||||
(uint32_t)env->regs[R_ESI],
|
|
||||||
(uint32_t)env->regs[R_EDI],
|
|
||||||
(uint32_t)env->regs[R_EBP],
|
|
||||||
(uint32_t)env->regs[R_ESP],
|
|
||||||
(uint32_t)env->eip, eflags,
|
|
||||||
eflags & DF_MASK ? 'D' : '-',
|
|
||||||
eflags & CC_O ? 'O' : '-',
|
|
||||||
eflags & CC_S ? 'S' : '-',
|
|
||||||
eflags & CC_Z ? 'Z' : '-',
|
|
||||||
eflags & CC_A ? 'A' : '-',
|
|
||||||
eflags & CC_P ? 'P' : '-',
|
|
||||||
eflags & CC_C ? 'C' : '-',
|
|
||||||
env->hflags & HF_CPL_MASK,
|
|
||||||
(env->hflags >> HF_INHIBIT_IRQ_SHIFT) & 1,
|
|
||||||
(env->a20_mask >> 20) & 1,
|
|
||||||
(env->hflags >> HF_SMM_SHIFT) & 1,
|
|
||||||
cs->halted);
|
|
||||||
}
|
|
||||||
|
|
||||||
for(i = 0; i < 6; i++) {
|
|
||||||
cpu_x86_dump_seg_cache(env, f, cpu_fprintf, seg_name[i],
|
|
||||||
&env->segs[i]);
|
|
||||||
}
|
|
||||||
cpu_x86_dump_seg_cache(env, f, cpu_fprintf, "LDT", &env->ldt);
|
|
||||||
cpu_x86_dump_seg_cache(env, f, cpu_fprintf, "TR", &env->tr);
|
|
||||||
|
|
||||||
#ifdef TARGET_X86_64
|
|
||||||
if (env->hflags & HF_LMA_MASK) {
|
|
||||||
cpu_fprintf(f, "GDT= %016" PRIx64 " %08x\n",
|
|
||||||
env->gdt.base, env->gdt.limit);
|
|
||||||
cpu_fprintf(f, "IDT= %016" PRIx64 " %08x\n",
|
|
||||||
env->idt.base, env->idt.limit);
|
|
||||||
cpu_fprintf(f, "CR0=%08x CR2=%016" PRIx64 " CR3=%016" PRIx64 " CR4=%08x\n",
|
|
||||||
(uint32_t)env->cr[0],
|
|
||||||
env->cr[2],
|
|
||||||
env->cr[3],
|
|
||||||
(uint32_t)env->cr[4]);
|
|
||||||
for(i = 0; i < 4; i++)
|
|
||||||
cpu_fprintf(f, "DR%d=%016" PRIx64 " ", i, env->dr[i]);
|
|
||||||
cpu_fprintf(f, "\nDR6=%016" PRIx64 " DR7=%016" PRIx64 "\n",
|
|
||||||
env->dr[6], env->dr[7]);
|
|
||||||
} else
|
|
||||||
#endif
|
|
||||||
{
|
|
||||||
cpu_fprintf(f, "GDT= %08x %08x\n",
|
|
||||||
(uint32_t)env->gdt.base, env->gdt.limit);
|
|
||||||
cpu_fprintf(f, "IDT= %08x %08x\n",
|
|
||||||
(uint32_t)env->idt.base, env->idt.limit);
|
|
||||||
cpu_fprintf(f, "CR0=%08x CR2=%08x CR3=%08x CR4=%08x\n",
|
|
||||||
(uint32_t)env->cr[0],
|
|
||||||
(uint32_t)env->cr[2],
|
|
||||||
(uint32_t)env->cr[3],
|
|
||||||
(uint32_t)env->cr[4]);
|
|
||||||
for(i = 0; i < 4; i++) {
|
|
||||||
cpu_fprintf(f, "DR%d=" TARGET_FMT_lx " ", i, env->dr[i]);
|
|
||||||
}
|
|
||||||
cpu_fprintf(f, "\nDR6=" TARGET_FMT_lx " DR7=" TARGET_FMT_lx "\n",
|
|
||||||
env->dr[6], env->dr[7]);
|
|
||||||
}
|
|
||||||
if (flags & CPU_DUMP_CCOP) {
|
|
||||||
if ((unsigned)env->cc_op < CC_OP_NB)
|
|
||||||
snprintf(cc_op_name, sizeof(cc_op_name), "%s", cc_op_str[env->cc_op]);
|
|
||||||
else
|
|
||||||
snprintf(cc_op_name, sizeof(cc_op_name), "[%d]", env->cc_op);
|
|
||||||
#ifdef TARGET_X86_64
|
|
||||||
if (env->hflags & HF_CS64_MASK) {
|
|
||||||
cpu_fprintf(f, "CCS=%016" PRIx64 " CCD=%016" PRIx64 " CCO=%-8s\n",
|
|
||||||
env->cc_src, env->cc_dst,
|
|
||||||
cc_op_name);
|
|
||||||
} else
|
|
||||||
#endif
|
|
||||||
{
|
|
||||||
cpu_fprintf(f, "CCS=%08x CCD=%08x CCO=%-8s\n",
|
|
||||||
(uint32_t)env->cc_src, (uint32_t)env->cc_dst,
|
|
||||||
cc_op_name);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
cpu_fprintf(f, "EFER=%016" PRIx64 "\n", env->efer);
|
|
||||||
if (flags & CPU_DUMP_FPU) {
|
|
||||||
int fptag;
|
|
||||||
fptag = 0;
|
|
||||||
for(i = 0; i < 8; i++) {
|
|
||||||
fptag |= ((!env->fptags[i]) << i);
|
|
||||||
}
|
|
||||||
cpu_fprintf(f, "FCW=%04x FSW=%04x [ST=%d] FTW=%02x MXCSR=%08x\n",
|
|
||||||
env->fpuc,
|
|
||||||
(env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11,
|
|
||||||
env->fpstt,
|
|
||||||
fptag,
|
|
||||||
env->mxcsr);
|
|
||||||
for(i=0;i<8;i++) {
|
|
||||||
CPU_LDoubleU u;
|
|
||||||
u.d = env->fpregs[i].d;
|
|
||||||
cpu_fprintf(f, "FPR%d=%016" PRIx64 " %04x",
|
|
||||||
i, u.l.lower, u.l.upper);
|
|
||||||
if ((i & 1) == 1)
|
|
||||||
cpu_fprintf(f, "\n");
|
|
||||||
else
|
|
||||||
cpu_fprintf(f, " ");
|
|
||||||
}
|
|
||||||
if (env->hflags & HF_CS64_MASK)
|
|
||||||
nb = 16;
|
|
||||||
else
|
|
||||||
nb = 8;
|
|
||||||
for(i=0;i<nb;i++) {
|
|
||||||
cpu_fprintf(f, "XMM%02d=%08x%08x%08x%08x",
|
|
||||||
i,
|
|
||||||
env->xmm_regs[i].XMM_L(3),
|
|
||||||
env->xmm_regs[i].XMM_L(2),
|
|
||||||
env->xmm_regs[i].XMM_L(1),
|
|
||||||
env->xmm_regs[i].XMM_L(0));
|
|
||||||
if ((i & 1) == 1)
|
|
||||||
cpu_fprintf(f, "\n");
|
|
||||||
else
|
|
||||||
cpu_fprintf(f, " ");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (flags & CPU_DUMP_CODE) {
|
|
||||||
target_ulong base = env->segs[R_CS].base + env->eip;
|
|
||||||
target_ulong offs = MIN(env->eip, DUMP_CODE_BYTES_BACKWARD);
|
|
||||||
uint8_t code;
|
|
||||||
char codestr[3];
|
|
||||||
|
|
||||||
cpu_fprintf(f, "Code=");
|
|
||||||
for (i = 0; i < DUMP_CODE_BYTES_TOTAL; i++) {
|
|
||||||
if (cpu_memory_rw_debug(cs, base - offs + i, &code, 1, 0) == 0) {
|
|
||||||
snprintf(codestr, sizeof(codestr), "%02x", code);
|
|
||||||
} else {
|
|
||||||
snprintf(codestr, sizeof(codestr), "??");
|
|
||||||
}
|
|
||||||
cpu_fprintf(f, "%s%s%s%s", i > 0 ? " " : "",
|
|
||||||
i == offs ? "<" : "", codestr, i == offs ? ">" : "");
|
|
||||||
}
|
|
||||||
cpu_fprintf(f, "\n");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/***********************************************************/
|
/***********************************************************/
|
||||||
/* x86 mmu */
|
/* x86 mmu */
|
||||||
/* XXX: add PGE support */
|
/* XXX: add PGE support */
|
||||||
|
|||||||
@ -70,11 +70,7 @@ static inline M68kCPU *m68k_env_get_cpu(CPUM68KState *env)
|
|||||||
|
|
||||||
void m68k_cpu_do_interrupt(CPUState *cpu);
|
void m68k_cpu_do_interrupt(CPUState *cpu);
|
||||||
bool m68k_cpu_exec_interrupt(CPUState *cpu, int int_req);
|
bool m68k_cpu_exec_interrupt(CPUState *cpu, int int_req);
|
||||||
void m68k_cpu_dump_state(CPUState *cpu, FILE *f, fprintf_function cpu_fprintf,
|
|
||||||
int flags);
|
|
||||||
hwaddr m68k_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr);
|
hwaddr m68k_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr);
|
||||||
int m68k_cpu_gdb_read_register(CPUState *cpu, uint8_t *buf, int reg);
|
|
||||||
int m68k_cpu_gdb_write_register(CPUState *cpu, uint8_t *buf, int reg);
|
|
||||||
|
|
||||||
void m68k_cpu_exec_enter(CPUState *cs);
|
void m68k_cpu_exec_enter(CPUState *cs);
|
||||||
void m68k_cpu_exec_exit(CPUState *cs);
|
void m68k_cpu_exec_exit(CPUState *cs);
|
||||||
|
|||||||
@ -19394,48 +19394,6 @@ void gen_intermediate_code_pc (CPUMIPSState *env, struct TranslationBlock *tb)
|
|||||||
gen_intermediate_code_internal(mips_env_get_cpu(env), tb, true);
|
gen_intermediate_code_internal(mips_env_get_cpu(env), tb, true);
|
||||||
}
|
}
|
||||||
|
|
||||||
#if 0
|
|
||||||
static void fpu_dump_state(CPUMIPSState *env, FILE *f, fprintf_function fpu_fprintf,
|
|
||||||
int flags)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
int is_fpu64 = !!(env->hflags & MIPS_HFLAG_F64);
|
|
||||||
|
|
||||||
#define printfpr(fp) \
|
|
||||||
do { \
|
|
||||||
if (is_fpu64) \
|
|
||||||
fpu_fprintf(f, "w:%08x d:%016" PRIx64 \
|
|
||||||
" fd:%13g fs:%13g psu: %13g\n", \
|
|
||||||
(fp)->w[FP_ENDIAN_IDX], (fp)->d, \
|
|
||||||
(double)(fp)->fd, \
|
|
||||||
(double)(fp)->fs[FP_ENDIAN_IDX], \
|
|
||||||
(double)(fp)->fs[!FP_ENDIAN_IDX]); \
|
|
||||||
else { \
|
|
||||||
fpr_t tmp; \
|
|
||||||
tmp.w[FP_ENDIAN_IDX] = (fp)->w[FP_ENDIAN_IDX]; \
|
|
||||||
tmp.w[!FP_ENDIAN_IDX] = ((fp) + 1)->w[FP_ENDIAN_IDX]; \
|
|
||||||
fpu_fprintf(f, "w:%08x d:%016" PRIx64 \
|
|
||||||
" fd:%13g fs:%13g psu:%13g\n", \
|
|
||||||
tmp.w[FP_ENDIAN_IDX], tmp.d, \
|
|
||||||
(double)tmp.fd, \
|
|
||||||
(double)tmp.fs[FP_ENDIAN_IDX], \
|
|
||||||
(double)tmp.fs[!FP_ENDIAN_IDX]); \
|
|
||||||
} \
|
|
||||||
} while(0)
|
|
||||||
|
|
||||||
|
|
||||||
fpu_fprintf(f, "CP1 FCR0 0x%08x FCR31 0x%08x SR.FR %d fp_status 0x%02x\n",
|
|
||||||
env->active_fpu.fcr0, env->active_fpu.fcr31, is_fpu64,
|
|
||||||
get_float_exception_flags(&env->active_fpu.fp_status));
|
|
||||||
for (i = 0; i < 32; (is_fpu64) ? i++ : (i += 2)) {
|
|
||||||
fpu_fprintf(f, "%3s: ", fregnames[i]);
|
|
||||||
printfpr(&env->active_fpu.fpr[i]);
|
|
||||||
}
|
|
||||||
|
|
||||||
#undef printfpr
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(TARGET_MIPS64) && defined(MIPS_DEBUG_SIGN_EXTENSIONS)
|
#if defined(TARGET_MIPS64) && defined(MIPS_DEBUG_SIGN_EXTENSIONS)
|
||||||
/* Debug help: The architecture requires 32bit code to maintain proper
|
/* Debug help: The architecture requires 32bit code to maintain proper
|
||||||
sign-extended values on 64bit machines. */
|
sign-extended values on 64bit machines. */
|
||||||
|
|||||||
@ -107,29 +107,13 @@ PowerPCCPUClass *ppc_cpu_class_by_pvr_mask(struct uc_struct *uc, uint32_t pvr);
|
|||||||
void ppc_cpu_do_interrupt(CPUState *cpu);
|
void ppc_cpu_do_interrupt(CPUState *cpu);
|
||||||
bool ppc_cpu_exec_interrupt(CPUState *cpu, int int_req);
|
bool ppc_cpu_exec_interrupt(CPUState *cpu, int int_req);
|
||||||
hwaddr ppc_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr);
|
hwaddr ppc_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr);
|
||||||
int ppc_cpu_gdb_read_register(CPUState *cpu, uint8_t *buf, int reg);
|
|
||||||
int ppc_cpu_gdb_read_register_apple(CPUState *cpu, uint8_t *buf, int reg);
|
|
||||||
int ppc_cpu_gdb_write_register(CPUState *cpu, uint8_t *buf, int reg);
|
|
||||||
int ppc_cpu_gdb_write_register_apple(CPUState *cpu, uint8_t *buf, int reg);
|
|
||||||
#ifndef CONFIG_USER_ONLY
|
#ifndef CONFIG_USER_ONLY
|
||||||
void ppc_cpu_do_system_reset(CPUState *cs);
|
void ppc_cpu_do_system_reset(CPUState *cs);
|
||||||
extern const struct VMStateDescription vmstate_ppc_cpu;
|
|
||||||
|
|
||||||
typedef struct PPCTimebase {
|
typedef struct PPCTimebase {
|
||||||
uint64_t guest_timebase;
|
uint64_t guest_timebase;
|
||||||
int64_t time_of_the_day_ns;
|
int64_t time_of_the_day_ns;
|
||||||
} PPCTimebase;
|
} PPCTimebase;
|
||||||
|
|
||||||
extern const struct VMStateDescription vmstate_ppc_timebase;
|
|
||||||
|
|
||||||
#define VMSTATE_PPC_TIMEBASE_V(_field, _state, _version) { \
|
|
||||||
.name = (stringify(_field)), \
|
|
||||||
.version_id = (_version), \
|
|
||||||
.size = sizeof(PPCTimebase), \
|
|
||||||
.vmsd = &vmstate_ppc_timebase, \
|
|
||||||
.flags = VMS_STRUCT, \
|
|
||||||
.offset = vmstate_offset_value(_state, _field, PPCTimebase), \
|
|
||||||
}
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|||||||
@ -11063,212 +11063,6 @@ GEN_SPEOP_LDST(evstwwo, 0x1E, 2),
|
|||||||
#include "helper_regs.h"
|
#include "helper_regs.h"
|
||||||
#include "translate_init.c"
|
#include "translate_init.c"
|
||||||
|
|
||||||
/*****************************************************************************/
|
|
||||||
/* Misc PowerPC helpers */
|
|
||||||
#if 0
|
|
||||||
void ppc_cpu_dump_state(struct uc_struct *uc, CPUState *cs, FILE *f, fprintf_function cpu_fprintf,
|
|
||||||
int flags)
|
|
||||||
{
|
|
||||||
#define RGPL 4
|
|
||||||
#define RFPL 4
|
|
||||||
|
|
||||||
PowerPCCPU *cpu = POWERPC_CPU(uc, cs);
|
|
||||||
CPUPPCState *env = &cpu->env;
|
|
||||||
int i;
|
|
||||||
|
|
||||||
cpu_fprintf(f, "NIP " TARGET_FMT_lx " LR " TARGET_FMT_lx " CTR "
|
|
||||||
TARGET_FMT_lx " XER " TARGET_FMT_lx "\n",
|
|
||||||
env->nip, env->lr, env->ctr, cpu_read_xer(env));
|
|
||||||
cpu_fprintf(f, "MSR " TARGET_FMT_lx " HID0 " TARGET_FMT_lx " HF "
|
|
||||||
TARGET_FMT_lx " idx %d\n", env->msr, env->spr[SPR_HID0],
|
|
||||||
env->hflags, env->mmu_idx);
|
|
||||||
#if !defined(NO_TIMER_DUMP)
|
|
||||||
cpu_fprintf(f, "TB %08" PRIu32 " %08" PRIu64
|
|
||||||
#if !defined(CONFIG_USER_ONLY)
|
|
||||||
" DECR %08" PRIu32
|
|
||||||
#endif
|
|
||||||
"\n",
|
|
||||||
cpu_ppc_load_tbu(env), cpu_ppc_load_tbl(env)
|
|
||||||
#if !defined(CONFIG_USER_ONLY)
|
|
||||||
, cpu_ppc_load_decr(env)
|
|
||||||
#endif
|
|
||||||
);
|
|
||||||
#endif
|
|
||||||
for (i = 0; i < 32; i++) {
|
|
||||||
if ((i & (RGPL - 1)) == 0)
|
|
||||||
cpu_fprintf(f, "GPR%02d", i);
|
|
||||||
cpu_fprintf(f, " %016" PRIx64, ppc_dump_gpr(env, i));
|
|
||||||
if ((i & (RGPL - 1)) == (RGPL - 1))
|
|
||||||
cpu_fprintf(f, "\n");
|
|
||||||
}
|
|
||||||
cpu_fprintf(f, "CR ");
|
|
||||||
for (i = 0; i < 8; i++)
|
|
||||||
cpu_fprintf(f, "%01x", env->crf[i]);
|
|
||||||
cpu_fprintf(f, " [");
|
|
||||||
for (i = 0; i < 8; i++) {
|
|
||||||
char a = '-';
|
|
||||||
if (env->crf[i] & 0x08)
|
|
||||||
a = 'L';
|
|
||||||
else if (env->crf[i] & 0x04)
|
|
||||||
a = 'G';
|
|
||||||
else if (env->crf[i] & 0x02)
|
|
||||||
a = 'E';
|
|
||||||
cpu_fprintf(f, " %c%c", a, env->crf[i] & 0x01 ? 'O' : ' ');
|
|
||||||
}
|
|
||||||
cpu_fprintf(f, " ] RES " TARGET_FMT_lx "\n",
|
|
||||||
env->reserve_addr);
|
|
||||||
for (i = 0; i < 32; i++) {
|
|
||||||
if ((i & (RFPL - 1)) == 0)
|
|
||||||
cpu_fprintf(f, "FPR%02d", i);
|
|
||||||
cpu_fprintf(f, " %016" PRIx64, *((uint64_t *)&env->fpr[i]));
|
|
||||||
if ((i & (RFPL - 1)) == (RFPL - 1))
|
|
||||||
cpu_fprintf(f, "\n");
|
|
||||||
}
|
|
||||||
cpu_fprintf(f, "FPSCR " TARGET_FMT_lx "\n", env->fpscr);
|
|
||||||
#if !defined(CONFIG_USER_ONLY)
|
|
||||||
cpu_fprintf(f, " SRR0 " TARGET_FMT_lx " SRR1 " TARGET_FMT_lx
|
|
||||||
" PVR " TARGET_FMT_lx " VRSAVE " TARGET_FMT_lx "\n",
|
|
||||||
env->spr[SPR_SRR0], env->spr[SPR_SRR1],
|
|
||||||
env->spr[SPR_PVR], env->spr[SPR_VRSAVE]);
|
|
||||||
|
|
||||||
cpu_fprintf(f, "SPRG0 " TARGET_FMT_lx " SPRG1 " TARGET_FMT_lx
|
|
||||||
" SPRG2 " TARGET_FMT_lx " SPRG3 " TARGET_FMT_lx "\n",
|
|
||||||
env->spr[SPR_SPRG0], env->spr[SPR_SPRG1],
|
|
||||||
env->spr[SPR_SPRG2], env->spr[SPR_SPRG3]);
|
|
||||||
|
|
||||||
cpu_fprintf(f, "SPRG4 " TARGET_FMT_lx " SPRG5 " TARGET_FMT_lx
|
|
||||||
" SPRG6 " TARGET_FMT_lx " SPRG7 " TARGET_FMT_lx "\n",
|
|
||||||
env->spr[SPR_SPRG4], env->spr[SPR_SPRG5],
|
|
||||||
env->spr[SPR_SPRG6], env->spr[SPR_SPRG7]);
|
|
||||||
|
|
||||||
if (env->excp_model == POWERPC_EXCP_BOOKE) {
|
|
||||||
cpu_fprintf(f, "CSRR0 " TARGET_FMT_lx " CSRR1 " TARGET_FMT_lx
|
|
||||||
" MCSRR0 " TARGET_FMT_lx " MCSRR1 " TARGET_FMT_lx "\n",
|
|
||||||
env->spr[SPR_BOOKE_CSRR0], env->spr[SPR_BOOKE_CSRR1],
|
|
||||||
env->spr[SPR_BOOKE_MCSRR0], env->spr[SPR_BOOKE_MCSRR1]);
|
|
||||||
|
|
||||||
cpu_fprintf(f, " TCR " TARGET_FMT_lx " TSR " TARGET_FMT_lx
|
|
||||||
" ESR " TARGET_FMT_lx " DEAR " TARGET_FMT_lx "\n",
|
|
||||||
env->spr[SPR_BOOKE_TCR], env->spr[SPR_BOOKE_TSR],
|
|
||||||
env->spr[SPR_BOOKE_ESR], env->spr[SPR_BOOKE_DEAR]);
|
|
||||||
|
|
||||||
cpu_fprintf(f, " PIR " TARGET_FMT_lx " DECAR " TARGET_FMT_lx
|
|
||||||
" IVPR " TARGET_FMT_lx " EPCR " TARGET_FMT_lx "\n",
|
|
||||||
env->spr[SPR_BOOKE_PIR], env->spr[SPR_BOOKE_DECAR],
|
|
||||||
env->spr[SPR_BOOKE_IVPR], env->spr[SPR_BOOKE_EPCR]);
|
|
||||||
|
|
||||||
cpu_fprintf(f, " MCSR " TARGET_FMT_lx " SPRG8 " TARGET_FMT_lx
|
|
||||||
" EPR " TARGET_FMT_lx "\n",
|
|
||||||
env->spr[SPR_BOOKE_MCSR], env->spr[SPR_BOOKE_SPRG8],
|
|
||||||
env->spr[SPR_BOOKE_EPR]);
|
|
||||||
|
|
||||||
/* FSL-specific */
|
|
||||||
cpu_fprintf(f, " MCAR " TARGET_FMT_lx " PID1 " TARGET_FMT_lx
|
|
||||||
" PID2 " TARGET_FMT_lx " SVR " TARGET_FMT_lx "\n",
|
|
||||||
env->spr[SPR_Exxx_MCAR], env->spr[SPR_BOOKE_PID1],
|
|
||||||
env->spr[SPR_BOOKE_PID2], env->spr[SPR_E500_SVR]);
|
|
||||||
|
|
||||||
/*
|
|
||||||
* IVORs are left out as they are large and do not change often --
|
|
||||||
* they can be read with "p $ivor0", "p $ivor1", etc.
|
|
||||||
*/
|
|
||||||
}
|
|
||||||
|
|
||||||
#if defined(TARGET_PPC64)
|
|
||||||
if (env->flags & POWERPC_FLAG_CFAR) {
|
|
||||||
cpu_fprintf(f, " CFAR " TARGET_FMT_lx"\n", env->cfar);
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
switch (env->mmu_model) {
|
|
||||||
case POWERPC_MMU_32B:
|
|
||||||
case POWERPC_MMU_601:
|
|
||||||
case POWERPC_MMU_SOFT_6xx:
|
|
||||||
case POWERPC_MMU_SOFT_74xx:
|
|
||||||
#if defined(TARGET_PPC64)
|
|
||||||
case POWERPC_MMU_64B:
|
|
||||||
case POWERPC_MMU_2_06:
|
|
||||||
case POWERPC_MMU_2_06a:
|
|
||||||
case POWERPC_MMU_2_06d:
|
|
||||||
#endif
|
|
||||||
cpu_fprintf(f, " SDR1 " TARGET_FMT_lx " DAR " TARGET_FMT_lx
|
|
||||||
" DSISR " TARGET_FMT_lx "\n", env->spr[SPR_SDR1],
|
|
||||||
env->spr[SPR_DAR], env->spr[SPR_DSISR]);
|
|
||||||
break;
|
|
||||||
case POWERPC_MMU_BOOKE206:
|
|
||||||
cpu_fprintf(f, " MAS0 " TARGET_FMT_lx " MAS1 " TARGET_FMT_lx
|
|
||||||
" MAS2 " TARGET_FMT_lx " MAS3 " TARGET_FMT_lx "\n",
|
|
||||||
env->spr[SPR_BOOKE_MAS0], env->spr[SPR_BOOKE_MAS1],
|
|
||||||
env->spr[SPR_BOOKE_MAS2], env->spr[SPR_BOOKE_MAS3]);
|
|
||||||
|
|
||||||
cpu_fprintf(f, " MAS4 " TARGET_FMT_lx " MAS6 " TARGET_FMT_lx
|
|
||||||
" MAS7 " TARGET_FMT_lx " PID " TARGET_FMT_lx "\n",
|
|
||||||
env->spr[SPR_BOOKE_MAS4], env->spr[SPR_BOOKE_MAS6],
|
|
||||||
env->spr[SPR_BOOKE_MAS7], env->spr[SPR_BOOKE_PID]);
|
|
||||||
|
|
||||||
cpu_fprintf(f, "MMUCFG " TARGET_FMT_lx " TLB0CFG " TARGET_FMT_lx
|
|
||||||
" TLB1CFG " TARGET_FMT_lx "\n",
|
|
||||||
env->spr[SPR_MMUCFG], env->spr[SPR_BOOKE_TLB0CFG],
|
|
||||||
env->spr[SPR_BOOKE_TLB1CFG]);
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#undef RGPL
|
|
||||||
#undef RFPL
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void ppc_cpu_dump_statistics(CPUState *cs, FILE*f,
|
|
||||||
fprintf_function cpu_fprintf, int flags)
|
|
||||||
{
|
|
||||||
#if defined(DO_PPC_STATISTICS)
|
|
||||||
PowerPCCPU *cpu = POWERPC_CPU(cs);
|
|
||||||
opc_handler_t **t1, **t2, **t3, *handler;
|
|
||||||
int op1, op2, op3;
|
|
||||||
|
|
||||||
t1 = cpu->env.opcodes;
|
|
||||||
for (op1 = 0; op1 < 64; op1++) {
|
|
||||||
handler = t1[op1];
|
|
||||||
if (is_indirect_opcode(handler)) {
|
|
||||||
t2 = ind_table(handler);
|
|
||||||
for (op2 = 0; op2 < 32; op2++) {
|
|
||||||
handler = t2[op2];
|
|
||||||
if (is_indirect_opcode(handler)) {
|
|
||||||
t3 = ind_table(handler);
|
|
||||||
for (op3 = 0; op3 < 32; op3++) {
|
|
||||||
handler = t3[op3];
|
|
||||||
if (handler->count == 0)
|
|
||||||
continue;
|
|
||||||
cpu_fprintf(f, "%02x %02x %02x (%02x %04d) %16s: "
|
|
||||||
"%016" PRIx64 " %" PRId64 "\n",
|
|
||||||
op1, op2, op3, op1, (op3 << 5) | op2,
|
|
||||||
handler->oname,
|
|
||||||
handler->count, handler->count);
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if (handler->count == 0)
|
|
||||||
continue;
|
|
||||||
cpu_fprintf(f, "%02x %02x (%02x %04d) %16s: "
|
|
||||||
"%016" PRIx64 " %" PRId64 "\n",
|
|
||||||
op1, op2, op1, op2, handler->oname,
|
|
||||||
handler->count, handler->count);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
if (handler->count == 0)
|
|
||||||
continue;
|
|
||||||
cpu_fprintf(f, "%02x (%02x ) %16s: %016" PRIx64
|
|
||||||
" %" PRId64 "\n",
|
|
||||||
op1, op1, handler->oname,
|
|
||||||
handler->count, handler->count);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
#endif // #if 0
|
|
||||||
/*****************************************************************************/
|
/*****************************************************************************/
|
||||||
static inline void gen_intermediate_code_internal(PowerPCCPU *cpu,
|
static inline void gen_intermediate_code_internal(PowerPCCPU *cpu,
|
||||||
TranslationBlock *tb,
|
TranslationBlock *tb,
|
||||||
|
|||||||
@ -2224,35 +2224,13 @@ static void ppc_cpu_class_init(struct uc_struct *uc, CPUClass *oc, void *data)
|
|||||||
cc->has_work = ppc_cpu_has_work;
|
cc->has_work = ppc_cpu_has_work;
|
||||||
cc->do_interrupt = ppc_cpu_do_interrupt;
|
cc->do_interrupt = ppc_cpu_do_interrupt;
|
||||||
cc->cpu_exec_interrupt = ppc_cpu_exec_interrupt;
|
cc->cpu_exec_interrupt = ppc_cpu_exec_interrupt;
|
||||||
// cc->dump_state = ppc_cpu_dump_state;
|
|
||||||
// cc->dump_statistics = ppc_cpu_dump_statistics;
|
|
||||||
cc->set_pc = ppc_cpu_set_pc;
|
cc->set_pc = ppc_cpu_set_pc;
|
||||||
// cc->gdb_read_register = ppc_cpu_gdb_read_register;
|
|
||||||
// cc->gdb_write_register = ppc_cpu_gdb_write_register;
|
|
||||||
#ifdef CONFIG_USER_ONLY
|
#ifdef CONFIG_USER_ONLY
|
||||||
cc->handle_mmu_fault = ppc_cpu_handle_mmu_fault;
|
cc->handle_mmu_fault = ppc_cpu_handle_mmu_fault;
|
||||||
#else
|
#else
|
||||||
cc->get_phys_page_debug = ppc_cpu_get_phys_page_debug;
|
cc->get_phys_page_debug = ppc_cpu_get_phys_page_debug;
|
||||||
// cc->vmsd = &vmstate_ppc_cpu;
|
|
||||||
#endif
|
#endif
|
||||||
cc->cpu_exec_enter = ppc_cpu_exec_enter;
|
cc->cpu_exec_enter = ppc_cpu_exec_enter;
|
||||||
|
|
||||||
// cc->gdb_num_core_regs = 71;
|
|
||||||
|
|
||||||
//#ifdef USE_APPLE_GDB
|
|
||||||
// cc->gdb_read_register = ppc_cpu_gdb_read_register_apple;
|
|
||||||
// cc->gdb_write_register = ppc_cpu_gdb_write_register_apple;
|
|
||||||
// cc->gdb_num_core_regs = 71 + 32;
|
|
||||||
//#endif
|
|
||||||
|
|
||||||
//#if defined(TARGET_PPC64)
|
|
||||||
// cc->gdb_core_xml_file = "power64-core.xml";
|
|
||||||
//#else
|
|
||||||
// cc->gdb_core_xml_file = "power-core.xml";
|
|
||||||
//#endif
|
|
||||||
//#ifndef CONFIG_USER_ONLY
|
|
||||||
// cc->virtio_is_big_endian = ppc_cpu_is_big_endian;
|
|
||||||
//#endif
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/* PowerPC CPU definitions from cpu-models.c*/
|
/* PowerPC CPU definitions from cpu-models.c*/
|
||||||
|
|||||||
@ -70,11 +70,7 @@ static inline SPARCCPU *sparc_env_get_cpu(CPUSPARCState *env)
|
|||||||
#define ENV_OFFSET offsetof(SPARCCPU, env)
|
#define ENV_OFFSET offsetof(SPARCCPU, env)
|
||||||
|
|
||||||
void sparc_cpu_do_interrupt(CPUState *cpu);
|
void sparc_cpu_do_interrupt(CPUState *cpu);
|
||||||
void sparc_cpu_dump_state(CPUState *cpu, FILE *f,
|
|
||||||
fprintf_function cpu_fprintf, int flags);
|
|
||||||
hwaddr sparc_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr);
|
hwaddr sparc_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr);
|
||||||
int sparc_cpu_gdb_read_register(CPUState *cpu, uint8_t *buf, int reg);
|
|
||||||
int sparc_cpu_gdb_write_register(CPUState *cpu, uint8_t *buf, int reg);
|
|
||||||
void QEMU_NORETURN sparc_cpu_do_unaligned_access(CPUState *cpu,
|
void QEMU_NORETURN sparc_cpu_do_unaligned_access(CPUState *cpu,
|
||||||
vaddr addr, int is_write,
|
vaddr addr, int is_write,
|
||||||
int is_user, uintptr_t retaddr);
|
int is_user, uintptr_t retaddr);
|
||||||
|
|||||||
@ -699,7 +699,6 @@ static void sparc_cpu_class_init(struct uc_struct *uc, CPUClass *oc, void *data)
|
|||||||
cc->has_work = sparc_cpu_has_work;
|
cc->has_work = sparc_cpu_has_work;
|
||||||
cc->do_interrupt = sparc_cpu_do_interrupt;
|
cc->do_interrupt = sparc_cpu_do_interrupt;
|
||||||
cc->cpu_exec_interrupt = sparc_cpu_exec_interrupt;
|
cc->cpu_exec_interrupt = sparc_cpu_exec_interrupt;
|
||||||
//cc->dump_state = sparc_cpu_dump_state;
|
|
||||||
#if !defined(TARGET_SPARC64) && !defined(CONFIG_USER_ONLY)
|
#if !defined(TARGET_SPARC64) && !defined(CONFIG_USER_ONLY)
|
||||||
cc->memory_rw_debug = sparc_cpu_memory_rw_debug;
|
cc->memory_rw_debug = sparc_cpu_memory_rw_debug;
|
||||||
#endif
|
#endif
|
||||||
|
|||||||
Loading…
Reference in New Issue
Block a user