/* XXX: fix it to restore all registers */
void tlb_fill(CPUState *cs, target_ulong addr, MMUAccessType access_type,
int mmu_idx, uintptr_t retaddr)
{
int ret;
ret = s390_cpu_handle_mmu_fault(cs, addr, access_type, mmu_idx);
if (unlikely(ret != 0)) {
if (likely(retaddr)) {
/* now we have a real cpu fault */
cpu_restore_state(cs, retaddr);
}
cpu_loop_exit(cs);
}
}
/* Try to fill the TLB and return an exception if error. If retaddr is
NULL, it means that the function was called in C code (i.e. not
from generated code or from helper.c) */
void tlb_fill(CPUMBState *env, target_ulong addr, int is_write, int mmu_idx,
uintptr_t retaddr)
{
int ret;
ret = cpu_mb_handle_mmu_fault(env, addr, is_write, mmu_idx);
if (unlikely(ret)) {
if (retaddr) {
/* now we have a real cpu fault */
cpu_restore_state(env, retaddr);
}
cpu_loop_exit(env);
}
}
/* XXX: fix it to restore all registers */
void tlb_fill(CPUState *cs, target_ulong addr, MMUAccessType access_type,
int mmu_idx, uintptr_t retaddr)
{
int ret;
ret = alpha_cpu_handle_mmu_fault(cs, addr, access_type, mmu_idx);
if (unlikely(ret != 0)) {
if (retaddr) {
cpu_restore_state(cs, retaddr);
}
/* Exception index and error code are already set */
cpu_loop_exit(cs);
}
}
/* XXX: fix it to restore all registers */
void tlb_fill(CPUAlphaState *env, target_ulong addr, int is_write,
int mmu_idx, uintptr_t retaddr)
{
int ret;
ret = cpu_alpha_handle_mmu_fault(env, addr, is_write, mmu_idx);
if (unlikely(ret != 0)) {
if (retaddr) {
cpu_restore_state(env, retaddr);
}
/* Exception index and error code are already set */
cpu_loop_exit(env);
}
}
static void cpu_restore_state_from_retaddr(void *retaddr)
{
TranslationBlock *tb;
unsigned long pc;
if (retaddr) {
pc = (unsigned long) retaddr;
tb = tb_find_pc(pc);
if (tb) {
/* the PC is inside the translated code. It means that we have
a virtual CPU fault */
cpu_restore_state(tb, env, pc);
}
}
}
void tlb_fill(CPUOpenRISCState *env, target_ulong addr, int is_write,
int mmu_idx, uintptr_t retaddr)
{
int ret;
ret = cpu_openrisc_handle_mmu_fault(env, addr, is_write, mmu_idx);
if (ret) {
if (retaddr) {
/* now we have a real cpu fault. */
cpu_restore_state(env, retaddr);
}
/* Raise Exception. */
cpu_loop_exit(env);
}
}
/* XXX: fix it to restore all registers */
void tlb_fill(CPUState *cs, target_ulong addr, int is_write, int mmu_idx,
uintptr_t retaddr)
{
int ret;
ret = x86_cpu_handle_mmu_fault(cs, addr, is_write, mmu_idx);
if (ret) {
X86CPU *cpu = X86_CPU(cs);
CPUX86State *env = &cpu->env;
if (retaddr) {
/* now we have a real cpu fault */
cpu_restore_state(cs, retaddr);
}
raise_exception_err(env, cs->exception_index, env->error_code);
}
}
/* Raise an exception dynamically from a helper function. */
void QEMU_NORETURN runtime_exception(CPUS390XState *env, int excp,
uintptr_t retaddr)
{
int t;
env->exception_index = EXCP_PGM;
env->int_pgm_code = excp;
/* Use the (ultimate) callers address to find the insn that trapped. */
cpu_restore_state(env, retaddr);
/* Advance past the insn. */
t = cpu_ldub_code(env, env->psw.addr);
env->int_pgm_ilen = t = get_ilen(t);
env->psw.addr += 2 * t;
cpu_loop_exit(env);
}
/* Try to fill the TLB and return an exception if error. If retaddr is
NULL, it means that the function was called in C code (i.e. not
from generated code or from helper.c) */
void tlb_fill(CPUCRISState *env, target_ulong addr, int is_write, int mmu_idx,
uintptr_t retaddr)
{
int ret;
D_LOG("%s pc=%x tpc=%x ra=%p\n", __func__,
env->pc, env->debug1, (void *)retaddr);
ret = cpu_cris_handle_mmu_fault(env, addr, is_write, mmu_idx);
if (unlikely(ret)) {
if (retaddr) {
/* now we have a real cpu fault */
if (cpu_restore_state(env, retaddr)) {
/* Evaluate flags after retranslation. */
helper_top_evaluate_flags(env);
}
}
cpu_loop_exit(env);
}
}
void alpha_cpu_do_transaction_failed(CPUState *cs, hwaddr physaddr,
vaddr addr, unsigned size,
MMUAccessType access_type,
int mmu_idx, MemTxAttrs attrs,
MemTxResult response, uintptr_t retaddr)
{
AlphaCPU *cpu = ALPHA_CPU(cs);
CPUAlphaState *env = &cpu->env;
if (retaddr) {
cpu_restore_state(cs, retaddr);
}
env->trap_arg0 = addr;
env->trap_arg1 = access_type == MMU_DATA_STORE ? 1 : 0;
cs->exception_index = EXCP_MCHK;
env->error_code = 0;
cpu_loop_exit(cs);
}
/* XXX: fix it to restore all registers */
void tlb_fill(CPUX86State *env, target_ulong addr, int is_write, int mmu_idx,
uintptr_t retaddr)
{
TranslationBlock *tb;
int ret;
ret = cpu_x86_handle_mmu_fault(env, addr, is_write, mmu_idx);
if (ret) {
if (retaddr) {
/* now we have a real cpu fault */
tb = tb_find_pc(retaddr);
if (tb) {
/* the PC is inside the translated code. It means that we have
a virtual CPU fault */
cpu_restore_state(tb, env, retaddr);
}
}
raise_exception_err(env, env->exception_index, env->error_code);
}
}
static void do_unaligned_access(CPUAlphaState *env, target_ulong addr,
int is_write, int is_user, uintptr_t retaddr)
{
uint64_t pc;
uint32_t insn;
if (retaddr) {
cpu_restore_state(env, retaddr);
}
pc = env->pc;
insn = cpu_ldl_code(env, pc);
env->trap_arg0 = addr;
env->trap_arg1 = insn >> 26; /* opcode */
env->trap_arg2 = (insn >> 21) & 31; /* dest regno */
env->exception_index = EXCP_UNALIGN;
env->error_code = 0;
cpu_loop_exit(env);
}
/* Try to fill the TLB and return an exception if error. If retaddr is
NULL, it means that the function was called in C code (i.e. not
from generated code or from helper.c) */
void tlb_fill(CPUState *cs, target_ulong addr, int is_write, int mmu_idx,
uintptr_t retaddr)
{
CRISCPU *cpu = CRIS_CPU(cs);
CPUCRISState *env = &cpu->env;
int ret;
D_LOG("%s pc=%x tpc=%x ra=%p\n", __func__,
env->pc, env->pregs[PR_EDA], (void *)retaddr);
ret = cris_cpu_handle_mmu_fault(cs, addr, is_write, mmu_idx);
if (unlikely(ret)) {
if (retaddr) {
/* now we have a real cpu fault */
if (cpu_restore_state(cs, retaddr)) {
/* Evaluate flags after retranslation. */
helper_top_evaluate_flags(env);
}
}
cpu_loop_exit(cs);
}
}
void tlb_fill(CPUXtensaState *env,
target_ulong vaddr, int is_write, int mmu_idx, uintptr_t retaddr)
{
uint32_t paddr;
uint32_t page_size;
unsigned access;
int ret = xtensa_get_physical_addr(env, true, vaddr, is_write, mmu_idx,
&paddr, &page_size, &access);
qemu_log("%s(%08x, %d, %d) -> %08x, ret = %d\n", __func__,
vaddr, is_write, mmu_idx, paddr, ret);
if (ret == 0) {
tlb_set_page(env,
vaddr & TARGET_PAGE_MASK,
paddr & TARGET_PAGE_MASK,
access, mmu_idx, page_size);
} else {
cpu_restore_state(env, retaddr);
HELPER(exception_cause_vaddr)(env, env->pc, ret, vaddr);
}
}
void alpha_cpu_do_unaligned_access(CPUState *cs, vaddr addr,
MMUAccessType access_type,
int mmu_idx, uintptr_t retaddr)
{
AlphaCPU *cpu = ALPHA_CPU(cs);
CPUAlphaState *env = &cpu->env;
uint64_t pc;
uint32_t insn;
if (retaddr) {
cpu_restore_state(cs, retaddr);
}
pc = env->pc;
insn = cpu_ldl_code(env, pc);
env->trap_arg0 = addr;
env->trap_arg1 = insn >> 26; /* opcode */
env->trap_arg2 = (insn >> 21) & 31; /* dest regno */
cs->exception_index = EXCP_UNALIGN;
env->error_code = 0;
cpu_loop_exit(cs);
}
void gb_restore_state(FILE * fd, const byte *buf)
{
const int tbl_ram[]={1,1,1,4,16,8}; // 0と1は保険
const int has_bat[]={0,0,0,1,0,0,1,0,0,1,0,0,1,1,0,1,1,0,0,1,0,0,0,0,0,0,0,1,0,1,1,0}; // 0x20以下
int gb_type,dmy;
read_state(fd, &gb_type, sizeof(int));
rom_get_info()->gb_type=gb_type;
if (gb_type<=2){
read_state(fd, cpu_get_ram(),0x2000); // ram
read_state(fd, cpu_get_vram(),0x2000); // vram
read_state(fd, get_sram(),tbl_ram[rom_get_info()->ram_size]*0x2000); // sram
read_state(fd, cpu_get_oam(),0xA0);
read_state(fd, cpu_get_stack(),0x80);
int page,ram_page;
read_state(fd, &page, sizeof(int)); // rom_page
read_state(fd, &ram_page, sizeof(int)); // ram_page
mbc_set_page(page,ram_page);
read_state(fd, cpu_get_c_regs(),sizeof(struct cpu_regs)); // cpu_reg
cpu_set_c_regs();
read_state(fd, (void *)&g_regs,sizeof(struct gb_regs)); // sys_reg
int halt;
read_state(fd, &halt,sizeof(int));
*cpu_get_halt()=((halt)?true:false);
read_state(fd, &dmy,sizeof(int));
int mbc_dat;
read_state(fd, &mbc_dat,sizeof(int)); // MBC
mbc_set_state(mbc_dat);
int ext_is;
read_state(fd, &ext_is,sizeof(int));
mbc_set_ext_is(ext_is?true:false);
// ver 1.1 追加
byte tmp[256],tester[100];
// read_state(fd, tmp, 100); // とりあえず調べてみる
// _memset(tester,0,100);
// if (_memcmp(tmp,tester,100)!=0){
// apu 部分
// sceIoLseek(fd, -100, 1);
read_state(fd, apu_get_stat_cpu(),sizeof(struct apu_stat));
read_state(fd, apu_get_mem(),0x30);
read_state(fd, apu_get_stat_gen(),sizeof(struct apu_stat));
// }
byte resurved[256];
read_state(fd, resurved, 256);//将来のために確保
// RIN拡張
if(gb_type==2 && sgb_mode){
int dmy;
read_state(fd, &dmy, sizeof(int));
read_state(fd, &bit_received, sizeof(int));
read_state(fd, &bits_received, sizeof(int));
read_state(fd, &packets_received, sizeof(int));
read_state(fd, &sgb_state, sizeof(int));
read_state(fd, &sgb_index, sizeof(int));
read_state(fd, &sgb_multiplayer, sizeof(int));
read_state(fd, &sgb_fourplayers, sizeof(int));
read_state(fd, &sgb_nextcontrol, sizeof(int));
read_state(fd, &sgb_readingcontrol, sizeof(int));
read_state(fd, &sgb_mask, sizeof(int));
read_state(fd, sgb_palette, sizeof(unsigned short)*8*16);
read_state(fd, sgb_palette_memory, sizeof(unsigned short)*512*4);
read_state(fd, sgb_buffer, 7*16);
read_state(fd, sgb_ATF, 18*20);
read_state(fd, sgb_ATF_list, 45*20*18);
/*
read_state(fd, sgb_border, 2048);
read_state(fd, sgb_borderchar, 32*256);
read_state(fd, border_tmp, sizeof(border_tmp));
int i, j, n=0;
for (i=0; i<224; i++){
for (j=0; j<256; j++){
if (i>=40 && i<=183 && j==48) j=208;
sgb_border_buffer[i*256+j] = border_tmp[n++];
}
}
*/
}
}
else if (gb_type>=3){ // GB Colour / GBA
read_state(fd, cpu_get_ram(),0x2000*4); // ram
read_state(fd, cpu_get_vram(),0x2000*2); // vram
read_state(fd, get_sram(),tbl_ram[rom_get_info()->ram_size]*0x2000); // sram
read_state(fd, cpu_get_oam(),0xA0);
read_state(fd, cpu_get_stack(),0x80);
int cpu_dat[16];
int page,ram_page;
read_state(fd, &page, sizeof(int)); // rom_page
read_state(fd, &ram_page, sizeof(int)); // ram_page
mbc_set_page(page,ram_page);
page=(mbc_get_rom()-get_rom())/0x4000;
ram_page=(mbc_get_sram()-get_sram())/0x2000;
read_state(fd, cpu_dat+0,sizeof(int));//int_page
read_state(fd, cpu_dat+1,sizeof(int));//vram_page
int dmy;
read_state(fd, cpu_get_c_regs(),sizeof(struct cpu_regs)); // cpu_reg
cpu_set_c_regs();
read_state(fd, &g_regs,sizeof(struct gb_regs));//sys_reg
read_state(fd, &cg_regs,sizeof(struct gbc_regs));//col_reg
read_state(fd, lcd_get_pal_addr(),sizeof(word)*(8*4*2));//palette
int halt;
read_state(fd, &halt,sizeof(int));
*cpu_get_halt()=(halt?true:false);
read_state(fd, &dmy,sizeof(int)); // 元の版ではシリアル通信通信満了までのクロック数
int mbc_dat;
read_state(fd, &mbc_dat,sizeof(int)); // MBC
mbc_set_state(mbc_dat);
int ext_is;
read_state(fd, &ext_is,sizeof(int));
mbc_set_ext_is(ext_is?true:false);
//その他諸々
read_state(fd, cpu_dat+2,sizeof(int));
read_state(fd, cpu_dat+3,sizeof(int));
read_state(fd, cpu_dat+4,sizeof(int));
read_state(fd, cpu_dat+5,sizeof(int));
read_state(fd, cpu_dat+6,sizeof(int));
read_state(fd, cpu_dat+7,sizeof(int));
cpu_restore_state(cpu_dat);
// ver 1.1 追加
byte tmp[256],tester[100];
read_state(fd, apu_get_stat_cpu(),sizeof(struct apu_stat));
read_state(fd, apu_get_mem(),0x30);
read_state(fd, apu_get_stat_gen(),sizeof(struct apu_stat));
read_state(fd, tmp,1);
// }
byte resurved[256];
read_state(fd, resurved,256);//将来のために確保
}
cheat_create_cheat_map();
}