--- SheepShaver/src/kpx_cpu/sheepshaver_glue.cpp 2003/12/25 23:54:36 1.24 +++ SheepShaver/src/kpx_cpu/sheepshaver_glue.cpp 2005/06/30 10:17:58 1.64 @@ -1,7 +1,7 @@ /* * sheepshaver_glue.cpp - Glue Kheperix CPU to SheepShaver CPU engine interface * - * SheepShaver (C) 1997-2002 Christian Bauer and Marc Hellwig + * SheepShaver (C) 1997-2005 Christian Bauer and Marc Hellwig * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -38,8 +38,17 @@ #include "name_registry.h" #include "serial.h" #include "ether.h" +#include "timer.h" #include +#include +#ifdef HAVE_MALLOC_H +#include +#endif + +#ifdef USE_SDL_VIDEO +#include +#endif #if ENABLE_MON #include "mon.h" @@ -50,11 +59,13 @@ #include "debug.h" // Emulation time statistics -#define EMUL_TIME_STATS 1 +#ifndef EMUL_TIME_STATS +#define EMUL_TIME_STATS 0 +#endif #if EMUL_TIME_STATS static clock_t emul_start_time; -static uint32 interrupt_count = 0; +static uint32 interrupt_count = 0, ppc_interrupt_count = 0; static clock_t interrupt_time = 0; static uint32 exec68k_count = 0; static clock_t exec68k_time = 0; @@ -76,12 +87,12 @@ static void enter_mon(void) // From main_*.cpp extern uintptr SignalStackBase(); +// From rsrc_patches.cpp +extern "C" void check_load_invoc(uint32 type, int16 id, uint32 h); + // PowerPC EmulOp to exit from emulation looop const uint32 POWERPC_EXEC_RETURN = POWERPC_EMUL_OP | 1; -// Enable multicore (main/interrupts) cpu emulation? -#define MULTICORE_CPU (ASYNC_IRQ ? 1 : 0) - // Enable Execute68k() safety checks? #define SAFE_EXEC_68K 1 @@ -95,10 +106,16 @@ const uint32 POWERPC_EXEC_RETURN = POWER #define INTERRUPTS_IN_NATIVE_MODE 1 // Pointer to Kernel Data -static KernelData * const kernel_data = (KernelData *)KERNEL_DATA_BASE; +static KernelData * kernel_data; // SIGSEGV handler -static sigsegv_return_t sigsegv_handler(sigsegv_address_t, sigsegv_address_t); +sigsegv_return_t sigsegv_handler(sigsegv_address_t, sigsegv_address_t); + +#if PPC_ENABLE_JIT && PPC_REENTRANT_JIT +// Special trampolines for EmulOp and NativeOp +static uint8 *emul_op_trampoline; +static uint8 *native_op_trampoline; +#endif // JIT Compiler enabled? static inline bool enable_jit_p() @@ -133,6 +150,12 @@ public: uint32 get_xer() const { return xer().get(); } void set_xer(uint32 v) { xer().set(v); } + // Execute NATIVE_OP routine + void execute_native_op(uint32 native_op); + + // Execute EMUL_OP routine + void execute_emul_op(uint32 emul_op); + // Execute 68k routine void execute_68k(uint32 entry, M68kRegisters *r); @@ -142,27 +165,61 @@ public: // Execute MacOS/PPC code uint32 execute_macos_code(uint32 tvect, int nargs, uint32 const *args); +#if PPC_ENABLE_JIT + // Compile one instruction + virtual int compile1(codegen_context_t & cg_context); +#endif // Resource manager thunk void get_resource(uint32 old_get_resource); // Handle MacOS interrupt void interrupt(uint32 entry); - void handle_interrupt(); - - // Lazy memory allocator (one item at a time) - void *operator new(size_t size) - { return allocator_helper< sheepshaver_cpu, lazy_allocator >::allocate(); } - void operator delete(void *p) - { allocator_helper< sheepshaver_cpu, lazy_allocator >::deallocate(p); } - // FIXME: really make surre array allocation fail at link time? - void *operator new[](size_t); - void operator delete[](void *p); // Make sure the SIGSEGV handler can access CPU registers friend sigsegv_return_t sigsegv_handler(sigsegv_address_t, sigsegv_address_t); + + // Memory allocator returning areas aligned on 16-byte boundaries + void *operator new(size_t size); + void operator delete(void *p); }; -lazy_allocator< sheepshaver_cpu > allocator_helper< sheepshaver_cpu, lazy_allocator >::allocator; +// Memory allocator returning sheepshaver_cpu objects aligned on 16-byte boundaries +// FORMAT: [ alignment ] magic identifier, offset to malloc'ed data, sheepshaver_cpu data +void *sheepshaver_cpu::operator new(size_t size) +{ + const int ALIGN = 16; + + // Allocate enough space for sheepshaver_cpu data + signature + align pad + uint8 *ptr = (uint8 *)malloc(size + ALIGN * 2); + if (ptr == NULL) + throw std::bad_alloc(); + + // Align memory + int ofs = 0; + while ((((uintptr)ptr) % ALIGN) != 0) + ofs++, ptr++; + + // Insert signature and offset + struct aligned_block_t { + uint32 pad[(ALIGN - 8) / 4]; + uint32 signature; + uint32 offset; + uint8 data[sizeof(sheepshaver_cpu)]; + }; + aligned_block_t *blk = (aligned_block_t *)ptr; + blk->signature = FOURCC('S','C','P','U'); + blk->offset = ofs + (&blk->data[0] - (uint8 *)blk); + assert((((uintptr)&blk->data) % ALIGN) == 0); + return &blk->data[0]; +} + +void sheepshaver_cpu::operator delete(void *p) +{ + uint32 *blk = (uint32 *)p; + assert(blk[-2] == FOURCC('S','C','P','U')); + void *ptr = (void *)(((uintptr)p) - blk[-1]); + free(ptr); +} sheepshaver_cpu::sheepshaver_cpu() : powerpc_cpu(enable_jit_p()) @@ -172,13 +229,6 @@ sheepshaver_cpu::sheepshaver_cpu() void sheepshaver_cpu::init_decoder() { -#ifndef PPC_NO_STATIC_II_INDEX_TABLE - static bool initialized = false; - if (initialized) - return; - initialized = true; -#endif - static const instr_info_t sheep_ii_table[] = { { "sheep", (execute_pmf)&sheepshaver_cpu::execute_sheep, @@ -197,20 +247,41 @@ void sheepshaver_cpu::init_decoder() } } -// Forward declaration for native opcode handler -static void NativeOp(int selector); - /* NativeOp instruction format: - +------------+--------------------------+--+----------+------------+ - | 6 | |FN| OP | 2 | - +------------+--------------------------+--+----------+------------+ - 0 5 |6 19 20 21 25 26 31 + +------------+-------------------------+--+-----------+------------+ + | 6 | |FN| OP | 2 | + +------------+-------------------------+--+-----------+------------+ + 0 5 |6 18 19 20 25 26 31 */ -typedef bit_field< 20, 20 > FN_field; -typedef bit_field< 21, 25 > NATIVE_OP_field; +typedef bit_field< 19, 19 > FN_field; +typedef bit_field< 20, 25 > NATIVE_OP_field; typedef bit_field< 26, 31 > EMUL_OP_field; +// Execute EMUL_OP routine +void sheepshaver_cpu::execute_emul_op(uint32 emul_op) +{ + M68kRegisters r68; + WriteMacInt32(XLM_68K_R25, gpr(25)); + WriteMacInt32(XLM_RUN_MODE, MODE_EMUL_OP); + for (int i = 0; i < 8; i++) + r68.d[i] = gpr(8 + i); + for (int i = 0; i < 7; i++) + r68.a[i] = gpr(16 + i); + r68.a[7] = gpr(1); + uint32 saved_cr = get_cr() & 0xff9fffff; // mask_operand::compute(11, 8) + uint32 saved_xer = get_xer(); + EmulOp(&r68, gpr(24), emul_op); + set_cr(saved_cr); + set_xer(saved_xer); + for (int i = 0; i < 8; i++) + gpr(8 + i) = r68.d[i]; + for (int i = 0; i < 7; i++) + gpr(16 + i) = r68.a[i]; + gpr(1) = r68.a[7]; + WriteMacInt32(XLM_RUN_MODE, MODE_68K); +} + // Execute SheepShaver instruction void sheepshaver_cpu::execute_sheep(uint32 opcode) { @@ -227,54 +298,185 @@ void sheepshaver_cpu::execute_sheep(uint break; case 2: // EXEC_NATIVE - NativeOp(NATIVE_OP_field::extract(opcode)); + execute_native_op(NATIVE_OP_field::extract(opcode)); if (FN_field::test(opcode)) pc() = lr(); else pc() += 4; break; - default: { // EMUL_OP - M68kRegisters r68; - WriteMacInt32(XLM_68K_R25, gpr(25)); - WriteMacInt32(XLM_RUN_MODE, MODE_EMUL_OP); - for (int i = 0; i < 8; i++) - r68.d[i] = gpr(8 + i); - for (int i = 0; i < 7; i++) - r68.a[i] = gpr(16 + i); - r68.a[7] = gpr(1); - uint32 saved_cr = get_cr() & CR_field<2>::mask(); - uint32 saved_xer = get_xer(); - EmulOp(&r68, gpr(24), EMUL_OP_field::extract(opcode) - 3); - set_cr(saved_cr); - set_xer(saved_xer); - for (int i = 0; i < 8; i++) - gpr(8 + i) = r68.d[i]; - for (int i = 0; i < 7; i++) - gpr(16 + i) = r68.a[i]; - gpr(1) = r68.a[7]; - WriteMacInt32(XLM_RUN_MODE, MODE_68K); + default: // EMUL_OP + execute_emul_op(EMUL_OP_field::extract(opcode) - 3); pc() += 4; break; } +} + +// Compile one instruction +#if PPC_ENABLE_JIT +int sheepshaver_cpu::compile1(codegen_context_t & cg_context) +{ + const instr_info_t *ii = cg_context.instr_info; + if (ii->mnemo != PPC_I(SHEEP)) + return COMPILE_FAILURE; + + int status = COMPILE_FAILURE; + powerpc_dyngen & dg = cg_context.codegen; + uint32 opcode = cg_context.opcode; + + switch (opcode & 0x3f) { + case 0: // EMUL_RETURN + dg.gen_invoke(QuitEmulator); + status = COMPILE_CODE_OK; + break; + + case 1: // EXEC_RETURN + dg.gen_spcflags_set(SPCFLAG_CPU_EXEC_RETURN); + // Don't check for pending interrupts, we do know we have to + // get out of this block ASAP + dg.gen_exec_return(); + status = COMPILE_EPILOGUE_OK; + break; + + case 2: { // EXEC_NATIVE + uint32 selector = NATIVE_OP_field::extract(opcode); + switch (selector) { +#if !PPC_REENTRANT_JIT + // Filter out functions that may invoke Execute68k() or + // CallMacOS(), this would break reentrancy as they could + // invalidate the translation cache and even overwrite + // continuation code when we are done with them. + case NATIVE_PATCH_NAME_REGISTRY: + dg.gen_invoke(DoPatchNameRegistry); + status = COMPILE_CODE_OK; + break; + case NATIVE_VIDEO_INSTALL_ACCEL: + dg.gen_invoke(VideoInstallAccel); + status = COMPILE_CODE_OK; + break; + case NATIVE_VIDEO_VBL: + dg.gen_invoke(VideoVBL); + status = COMPILE_CODE_OK; + break; + case NATIVE_GET_RESOURCE: + case NATIVE_GET_1_RESOURCE: + case NATIVE_GET_IND_RESOURCE: + case NATIVE_GET_1_IND_RESOURCE: + case NATIVE_R_GET_RESOURCE: { + static const uint32 get_resource_ptr[] = { + XLM_GET_RESOURCE, + XLM_GET_1_RESOURCE, + XLM_GET_IND_RESOURCE, + XLM_GET_1_IND_RESOURCE, + XLM_R_GET_RESOURCE + }; + uint32 old_get_resource = ReadMacInt32(get_resource_ptr[selector - NATIVE_GET_RESOURCE]); + typedef void (*func_t)(dyngen_cpu_base, uint32); + func_t func = (func_t)nv_mem_fun(&sheepshaver_cpu::get_resource).ptr(); + dg.gen_invoke_CPU_im(func, old_get_resource); + status = COMPILE_CODE_OK; + break; + } + case NATIVE_CHECK_LOAD_INVOC: + dg.gen_load_T0_GPR(3); + dg.gen_load_T1_GPR(4); + dg.gen_se_16_32_T1(); + dg.gen_load_T2_GPR(5); + dg.gen_invoke_T0_T1_T2((void (*)(uint32, uint32, uint32))check_load_invoc); + status = COMPILE_CODE_OK; + break; +#endif + case NATIVE_BITBLT: + dg.gen_load_T0_GPR(3); + dg.gen_invoke_T0((void (*)(uint32))NQD_bitblt); + status = COMPILE_CODE_OK; + break; + case NATIVE_INVRECT: + dg.gen_load_T0_GPR(3); + dg.gen_invoke_T0((void (*)(uint32))NQD_invrect); + status = COMPILE_CODE_OK; + break; + case NATIVE_FILLRECT: + dg.gen_load_T0_GPR(3); + dg.gen_invoke_T0((void (*)(uint32))NQD_fillrect); + status = COMPILE_CODE_OK; + break; + } + // Could we fully translate this NativeOp? + if (status == COMPILE_CODE_OK) { + if (!FN_field::test(opcode)) + cg_context.done_compile = false; + else { + dg.gen_load_A0_LR(); + dg.gen_set_PC_A0(); + cg_context.done_compile = true; + } + break; + } +#if PPC_REENTRANT_JIT + // Try to execute NativeOp trampoline + if (!FN_field::test(opcode)) + dg.gen_set_PC_im(cg_context.pc + 4); + else { + dg.gen_load_A0_LR(); + dg.gen_set_PC_A0(); + } + dg.gen_mov_32_T0_im(selector); + dg.gen_jmp(native_op_trampoline); + cg_context.done_compile = true; + status = COMPILE_EPILOGUE_OK; + break; +#endif + // Invoke NativeOp handler + if (!FN_field::test(opcode)) { + typedef void (*func_t)(dyngen_cpu_base, uint32); + func_t func = (func_t)nv_mem_fun(&sheepshaver_cpu::execute_native_op).ptr(); + dg.gen_invoke_CPU_im(func, selector); + cg_context.done_compile = false; + status = COMPILE_CODE_OK; + } + // Otherwise, let it generate a call to execute_sheep() which + // will cause necessary updates to the program counter + break; } + + default: { // EMUL_OP + uint32 emul_op = EMUL_OP_field::extract(opcode) - 3; +#if PPC_REENTRANT_JIT + // Try to execute EmulOp trampoline + dg.gen_set_PC_im(cg_context.pc + 4); + dg.gen_mov_32_T0_im(emul_op); + dg.gen_jmp(emul_op_trampoline); + cg_context.done_compile = true; + status = COMPILE_EPILOGUE_OK; + break; +#endif + // Invoke EmulOp handler + typedef void (*func_t)(dyngen_cpu_base, uint32); + func_t func = (func_t)nv_mem_fun(&sheepshaver_cpu::execute_emul_op).ptr(); + dg.gen_invoke_CPU_im(func, emul_op); + cg_context.done_compile = false; + status = COMPILE_CODE_OK; + break; + } + } + return status; } +#endif // Handle MacOS interrupt void sheepshaver_cpu::interrupt(uint32 entry) { #if EMUL_TIME_STATS - interrupt_count++; + ppc_interrupt_count++; const clock_t interrupt_start = clock(); #endif -#if !MULTICORE_CPU // Save program counters and branch registers uint32 saved_pc = pc(); uint32 saved_lr = lr(); uint32 saved_ctr= ctr(); uint32 saved_sp = gpr(1); -#endif // Initialize stack pointer to SheepShaver alternate stack base gpr(1) = SignalStackBase() - 64; @@ -314,13 +516,11 @@ void sheepshaver_cpu::interrupt(uint32 e // Enter nanokernel execute(entry); -#if !MULTICORE_CPU // Restore program counters and branch registers pc() = saved_pc; lr() = saved_lr; ctr()= saved_ctr; gpr(1) = saved_sp; -#endif #if EMUL_TIME_STATS interrupt_time += (clock() - interrupt_start); @@ -493,8 +693,6 @@ inline void sheepshaver_cpu::execute_ppc } // Resource Manager thunk -extern "C" void check_load_invoc(uint32 type, int16 id, uint32 h); - inline void sheepshaver_cpu::get_resource(uint32 old_get_resource) { uint32 type = gpr(3); @@ -520,50 +718,32 @@ inline void sheepshaver_cpu::get_resourc * SheepShaver CPU engine interface **/ -static sheepshaver_cpu *main_cpu = NULL; // CPU emulator to handle usual control flow -static sheepshaver_cpu *interrupt_cpu = NULL; // CPU emulator to handle interrupts -static sheepshaver_cpu *current_cpu = NULL; // Current CPU emulator context +// PowerPC CPU emulator +static sheepshaver_cpu *ppc_cpu = NULL; void FlushCodeCache(uintptr start, uintptr end) { D(bug("FlushCodeCache(%08x, %08x)\n", start, end)); - main_cpu->invalidate_cache_range(start, end); -#if MULTICORE_CPU - interrupt_cpu->invalidate_cache_range(start, end); -#endif -} - -static inline void cpu_push(sheepshaver_cpu *new_cpu) -{ -#if MULTICORE_CPU - current_cpu = new_cpu; -#endif -} - -static inline void cpu_pop() -{ -#if MULTICORE_CPU - current_cpu = main_cpu; -#endif + ppc_cpu->invalidate_cache_range(start, end); } // Dump PPC registers static void dump_registers(void) { - current_cpu->dump_registers(); + ppc_cpu->dump_registers(); } // Dump log static void dump_log(void) { - current_cpu->dump_log(); + ppc_cpu->dump_log(); } /* * Initialize CPU emulation */ -static sigsegv_return_t sigsegv_handler(sigsegv_address_t fault_address, sigsegv_address_t fault_instruction) +sigsegv_return_t sigsegv_handler(sigsegv_address_t fault_address, sigsegv_address_t fault_instruction) { #if ENABLE_VOSF // Handle screen fault @@ -575,15 +755,15 @@ static sigsegv_return_t sigsegv_handler( const uintptr addr = (uintptr)fault_address; #if HAVE_SIGSEGV_SKIP_INSTRUCTION // Ignore writes to ROM - if ((addr - ROM_BASE) < ROM_SIZE) + if ((addr - (uintptr)ROMBaseHost) < ROM_SIZE) return SIGSEGV_RETURN_SKIP_INSTRUCTION; // Get program counter of target CPU - sheepshaver_cpu * const cpu = current_cpu; + sheepshaver_cpu * const cpu = ppc_cpu; const uint32 pc = cpu->pc(); // Fault in Mac ROM or RAM? - bool mac_fault = (pc >= ROM_BASE) && (pc < (ROM_BASE + ROM_AREA_SIZE)) || (pc >= RAMBase) && (pc < (RAMBase + RAMSize)); + bool mac_fault = (pc >= ROM_BASE) && (pc < (ROM_BASE + ROM_AREA_SIZE)) || (pc >= RAMBase) && (pc < (RAMBase + RAMSize)) || (pc >= DR_CACHE_BASE && pc < (DR_CACHE_BASE + DR_CACHE_SIZE)); if (mac_fault) { // "VM settings" during MacOS 8 installation @@ -603,6 +783,16 @@ static sigsegv_return_t sigsegv_handler( return SIGSEGV_RETURN_SKIP_INSTRUCTION; else if (pc == ROM_BASE + 0x4a10a0 && (cpu->gpr(20) == 0xf3012002 || cpu->gpr(20) == 0xf3012000)) return SIGSEGV_RETURN_SKIP_INSTRUCTION; + + // MacOS 8.6 serial drivers on startup (with DR Cache and OldWorld ROM) + else if ((pc - DR_CACHE_BASE) < DR_CACHE_SIZE && (cpu->gpr(16) == 0xf3012002 || cpu->gpr(16) == 0xf3012000)) + return SIGSEGV_RETURN_SKIP_INSTRUCTION; + else if ((pc - DR_CACHE_BASE) < DR_CACHE_SIZE && (cpu->gpr(20) == 0xf3012002 || cpu->gpr(20) == 0xf3012000)) + return SIGSEGV_RETURN_SKIP_INSTRUCTION; + + // Ignore writes to the zero page + else if ((uint32)(addr - SheepMem::ZeroPage()) < (uint32)SheepMem::PageSize()) + return SIGSEGV_RETURN_SKIP_INSTRUCTION; // Ignore all other faults, if requested if (PrefsFindBool("ignoresegv")) @@ -612,12 +802,11 @@ static sigsegv_return_t sigsegv_handler( #error "FIXME: You don't have the capability to skip instruction within signal handlers" #endif - printf("SIGSEGV\n"); - printf(" pc %p\n", fault_instruction); - printf(" ea %p\n", fault_address); - printf(" cpu %s\n", current_cpu == main_cpu ? "main" : "interrupts"); + fprintf(stderr, "SIGSEGV\n"); + fprintf(stderr, " pc %p\n", fault_instruction); + fprintf(stderr, " ea %p\n", fault_address); dump_registers(); - current_cpu->dump_log(); + ppc_cpu->dump_log(); enter_mon(); QuitEmulator(); @@ -626,20 +815,15 @@ static sigsegv_return_t sigsegv_handler( void init_emul_ppc(void) { + // Get pointer to KernelData in host address space + kernel_data = (KernelData *)Mac2HostAddr(KERNEL_DATA_BASE); + // Initialize main CPU emulator - main_cpu = new sheepshaver_cpu(); - main_cpu->set_register(powerpc_registers::GPR(3), any_register((uint32)ROM_BASE + 0x30d000)); - main_cpu->set_register(powerpc_registers::GPR(4), any_register(KernelDataAddr + 0x1000)); + ppc_cpu = new sheepshaver_cpu(); + ppc_cpu->set_register(powerpc_registers::GPR(3), any_register((uint32)ROM_BASE + 0x30d000)); + ppc_cpu->set_register(powerpc_registers::GPR(4), any_register(KernelDataAddr + 0x1000)); WriteMacInt32(XLM_RUN_MODE, MODE_68K); -#if MULTICORE_CPU - // Initialize alternate CPU emulator to handle interrupts - interrupt_cpu = new sheepshaver_cpu(); -#endif - - // Install the handler for SIGSEGV - sigsegv_install_handler(sigsegv_handler); - #if ENABLE_MON // Install "regs" command in cxmon mon_add_command("regs", dump_registers, "regs Dump PowerPC registers\n"); @@ -665,6 +849,8 @@ void exit_emul_ppc(void) printf("Total emulation time : %.1f sec\n", double(emul_time) / double(CLOCKS_PER_SEC)); printf("Total interrupt count: %d (%2.1f Hz)\n", interrupt_count, (double(interrupt_count) * CLOCKS_PER_SEC) / double(emul_time)); + printf("Total ppc interrupt count: %d (%2.1f %%)\n", ppc_interrupt_count, + (double(ppc_interrupt_count) * 100.0) / double(interrupt_count)); #define PRINT_STATS(LABEL, VAR_PREFIX) do { \ printf("Total " LABEL " count : %d\n", VAR_PREFIX##_count); \ @@ -681,75 +867,93 @@ void exit_emul_ppc(void) printf("\n"); #endif - delete main_cpu; -#if MULTICORE_CPU - delete interrupt_cpu; -#endif + delete ppc_cpu; } +#if PPC_ENABLE_JIT && PPC_REENTRANT_JIT +// Initialize EmulOp trampolines +void init_emul_op_trampolines(basic_dyngen & dg) +{ + typedef void (*func_t)(dyngen_cpu_base, uint32); + func_t func; + + // EmulOp + emul_op_trampoline = dg.gen_start(); + func = (func_t)nv_mem_fun(&sheepshaver_cpu::execute_emul_op).ptr(); + dg.gen_invoke_CPU_T0(func); + dg.gen_exec_return(); + dg.gen_end(); + + // NativeOp + native_op_trampoline = dg.gen_start(); + func = (func_t)nv_mem_fun(&sheepshaver_cpu::execute_native_op).ptr(); + dg.gen_invoke_CPU_T0(func); + dg.gen_exec_return(); + dg.gen_end(); + + D(bug("EmulOp trampoline: %p\n", emul_op_trampoline)); + D(bug("NativeOp trampoline: %p\n", native_op_trampoline)); +} +#endif + /* * Emulation loop */ void emul_ppc(uint32 entry) { - current_cpu = main_cpu; #if 0 - current_cpu->start_log(); + ppc_cpu->start_log(); #endif // start emulation loop and enable code translation or caching - current_cpu->execute(entry); + ppc_cpu->execute(entry); } /* * Handle PowerPC interrupt */ -#if ASYNC_IRQ -void HandleInterrupt(void) -{ - main_cpu->handle_interrupt(); -} -#else void TriggerInterrupt(void) { + idle_resume(); #if 0 WriteMacInt32(0x16a, ReadMacInt32(0x16a) + 1); #else // Trigger interrupt to main cpu only - if (main_cpu) - main_cpu->trigger_interrupt(); + if (ppc_cpu) + ppc_cpu->trigger_interrupt(); #endif } -#endif -void sheepshaver_cpu::handle_interrupt(void) +void HandleInterrupt(powerpc_registers *r) { - // Do nothing if interrupts are disabled - if (*(int32 *)XLM_IRQ_NEST > 0) - return; +#ifdef USE_SDL_VIDEO + // We must fill in the events queue in the same thread that did call SDL_SetVideoMode() + SDL_PumpEvents(); +#endif - // Do nothing if there is no interrupt pending - if (InterruptFlags == 0) + // Do nothing if interrupts are disabled + if (int32(ReadMacInt32(XLM_IRQ_NEST)) > 0) return; - // Disable MacOS stack sniffer - WriteMacInt32(0x110, 0); + // Update interrupt count +#if EMUL_TIME_STATS + interrupt_count++; +#endif // Interrupt action depends on current run mode switch (ReadMacInt32(XLM_RUN_MODE)) { case MODE_68K: // 68k emulator active, trigger 68k interrupt level 1 - assert(current_cpu == main_cpu); WriteMacInt16(tswap32(kernel_data->v[0x67c >> 2]), 1); - set_cr(get_cr() | tswap32(kernel_data->v[0x674 >> 2])); + r->cr.set(r->cr.get() | tswap32(kernel_data->v[0x674 >> 2])); break; #if INTERRUPTS_IN_NATIVE_MODE case MODE_NATIVE: // 68k emulator inactive, in nanokernel? - assert(current_cpu == main_cpu); - if (gpr(1) != KernelDataAddr) { + if (r->gpr[1] != KernelDataAddr) { + // Prepare for 68k interrupt level 1 WriteMacInt16(tswap32(kernel_data->v[0x67c >> 2]), 1); WriteMacInt32(tswap32(kernel_data->v[0x658 >> 2]) + 0xdc, @@ -758,12 +962,10 @@ void sheepshaver_cpu::handle_interrupt(v // Execute nanokernel interrupt routine (this will activate the 68k emulator) DisableInterrupt(); - cpu_push(interrupt_cpu); if (ROMType == ROMTYPE_NEWWORLD) - current_cpu->interrupt(ROM_BASE + 0x312b1c); + ppc_cpu->interrupt(ROM_BASE + 0x312b1c); else - current_cpu->interrupt(ROM_BASE + 0x312a3c); - cpu_pop(); + ppc_cpu->interrupt(ROM_BASE + 0x312a3c); } break; #endif @@ -772,12 +974,15 @@ void sheepshaver_cpu::handle_interrupt(v case MODE_EMUL_OP: // 68k emulator active, within EMUL_OP routine, execute 68k interrupt routine directly when interrupt level is 0 if ((ReadMacInt32(XLM_68K_R25) & 7) == 0) { +#if EMUL_TIME_STATS + const clock_t interrupt_start = clock(); +#endif #if 1 // Execute full 68k interrupt routine M68kRegisters r; uint32 old_r25 = ReadMacInt32(XLM_68K_R25); // Save interrupt level WriteMacInt32(XLM_68K_R25, 0x21); // Execute with interrupt level 1 - static const uint8 proc[] = { + static const uint8 proc_template[] = { 0x3f, 0x3c, 0x00, 0x00, // move.w #$0000,-(sp) (fake format word) 0x48, 0x7a, 0x00, 0x0a, // pea @1(pc) (return address) 0x40, 0xe7, // move sr,-(sp) (saved SR) @@ -785,7 +990,8 @@ void sheepshaver_cpu::handle_interrupt(v 0x4e, 0xd0, // jmp (a0) M68K_RTS >> 8, M68K_RTS & 0xff // @1 }; - Execute68k((uint32)proc, &r); + BUILD_SHEEPSHAVER_PROCEDURE(proc); + Execute68k(proc, &r); WriteMacInt32(XLM_68K_R25, old_r25); // Restore interrupt level #else // Only update cursor @@ -797,6 +1003,9 @@ void sheepshaver_cpu::handle_interrupt(v } } #endif +#if EMUL_TIME_STATS + interrupt_time += (clock() - interrupt_start); +#endif } break; #endif @@ -809,9 +1018,8 @@ static void get_ind_resource(void); static void get_1_ind_resource(void); static void r_get_resource(void); -#define GPR(REG) current_cpu->gpr(REG) - -static void NativeOp(int selector) +// Execute NATIVE_OP routine +void sheepshaver_cpu::execute_native_op(uint32 selector) { #if EMUL_TIME_STATS native_exec_count++; @@ -829,37 +1037,47 @@ static void NativeOp(int selector) VideoVBL(); break; case NATIVE_VIDEO_DO_DRIVER_IO: - GPR(3) = (int32)(int16)VideoDoDriverIO((void *)GPR(3), (void *)GPR(4), - (void *)GPR(5), GPR(6), GPR(7)); + gpr(3) = (int32)(int16)VideoDoDriverIO(gpr(3), gpr(4), gpr(5), gpr(6), gpr(7)); break; -#ifdef WORDS_BIGENDIAN case NATIVE_ETHER_IRQ: EtherIRQ(); break; case NATIVE_ETHER_INIT: - GPR(3) = InitStreamModule((void *)GPR(3)); + gpr(3) = InitStreamModule((void *)gpr(3)); break; case NATIVE_ETHER_TERM: TerminateStreamModule(); break; case NATIVE_ETHER_OPEN: - GPR(3) = ether_open((queue_t *)GPR(3), (void *)GPR(4), GPR(5), GPR(6), (void*)GPR(7)); + gpr(3) = ether_open((queue_t *)gpr(3), (void *)gpr(4), gpr(5), gpr(6), (void*)gpr(7)); break; case NATIVE_ETHER_CLOSE: - GPR(3) = ether_close((queue_t *)GPR(3), GPR(4), (void *)GPR(5)); + gpr(3) = ether_close((queue_t *)gpr(3), gpr(4), (void *)gpr(5)); break; case NATIVE_ETHER_WPUT: - GPR(3) = ether_wput((queue_t *)GPR(3), (mblk_t *)GPR(4)); + gpr(3) = ether_wput((queue_t *)gpr(3), (mblk_t *)gpr(4)); break; case NATIVE_ETHER_RSRV: - GPR(3) = ether_rsrv((queue_t *)GPR(3)); + gpr(3) = ether_rsrv((queue_t *)gpr(3)); break; -#else - case NATIVE_ETHER_INIT: - // FIXME: needs more complicated thunks - GPR(3) = false; + case NATIVE_SYNC_HOOK: + gpr(3) = NQD_sync_hook(gpr(3)); + break; + case NATIVE_BITBLT_HOOK: + gpr(3) = NQD_bitblt_hook(gpr(3)); + break; + case NATIVE_BITBLT: + NQD_bitblt(gpr(3)); + break; + case NATIVE_FILLRECT_HOOK: + gpr(3) = NQD_fillrect_hook(gpr(3)); + break; + case NATIVE_INVRECT: + NQD_invrect(gpr(3)); + break; + case NATIVE_FILLRECT: + NQD_fillrect(gpr(3)); break; -#endif case NATIVE_SERIAL_NOTHING: case NATIVE_SERIAL_OPEN: case NATIVE_SERIAL_PRIME_IN: @@ -877,7 +1095,7 @@ static void NativeOp(int selector) SerialStatus, SerialClose }; - GPR(3) = serial_callbacks[selector - NATIVE_SERIAL_NOTHING](GPR(3), GPR(4)); + gpr(3) = serial_callbacks[selector - NATIVE_SERIAL_NOTHING](gpr(3), gpr(4)); break; } case NATIVE_GET_RESOURCE: @@ -887,23 +1105,20 @@ static void NativeOp(int selector) case NATIVE_R_GET_RESOURCE: { typedef void (*GetResourceCallback)(void); static const GetResourceCallback get_resource_callbacks[] = { - get_resource, - get_1_resource, - get_ind_resource, - get_1_ind_resource, - r_get_resource + ::get_resource, + ::get_1_resource, + ::get_ind_resource, + ::get_1_ind_resource, + ::r_get_resource }; get_resource_callbacks[selector - NATIVE_GET_RESOURCE](); break; } - case NATIVE_DISABLE_INTERRUPT: - DisableInterrupt(); - break; - case NATIVE_ENABLE_INTERRUPT: - EnableInterrupt(); - break; case NATIVE_MAKE_EXECUTABLE: - MakeExecutable(0, (void *)GPR(4), GPR(5)); + MakeExecutable(0, gpr(4), gpr(5)); + break; + case NATIVE_CHECK_LOAD_INVOC: + check_load_invoc(gpr(3), gpr(4), gpr(5)); break; default: printf("FATAL: NATIVE_OP called with bogus selector %d\n", selector); @@ -924,7 +1139,7 @@ static void NativeOp(int selector) void Execute68k(uint32 pc, M68kRegisters *r) { - current_cpu->execute_68k(pc, r); + ppc_cpu->execute_68k(pc, r); } /* @@ -947,49 +1162,49 @@ void Execute68kTrap(uint16 trap, M68kReg uint32 call_macos(uint32 tvect) { - return current_cpu->execute_macos_code(tvect, 0, NULL); + return ppc_cpu->execute_macos_code(tvect, 0, NULL); } uint32 call_macos1(uint32 tvect, uint32 arg1) { const uint32 args[] = { arg1 }; - return current_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args); + return ppc_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args); } uint32 call_macos2(uint32 tvect, uint32 arg1, uint32 arg2) { const uint32 args[] = { arg1, arg2 }; - return current_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args); + return ppc_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args); } uint32 call_macos3(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3) { const uint32 args[] = { arg1, arg2, arg3 }; - return current_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args); + return ppc_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args); } uint32 call_macos4(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4) { const uint32 args[] = { arg1, arg2, arg3, arg4 }; - return current_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args); + return ppc_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args); } uint32 call_macos5(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4, uint32 arg5) { const uint32 args[] = { arg1, arg2, arg3, arg4, arg5 }; - return current_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args); + return ppc_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args); } uint32 call_macos6(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4, uint32 arg5, uint32 arg6) { const uint32 args[] = { arg1, arg2, arg3, arg4, arg5, arg6 }; - return current_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args); + return ppc_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args); } uint32 call_macos7(uint32 tvect, uint32 arg1, uint32 arg2, uint32 arg3, uint32 arg4, uint32 arg5, uint32 arg6, uint32 arg7) { const uint32 args[] = { arg1, arg2, arg3, arg4, arg5, arg6, arg7 }; - return current_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args); + return ppc_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args); } /* @@ -998,25 +1213,25 @@ uint32 call_macos7(uint32 tvect, uint32 void get_resource(void) { - current_cpu->get_resource(ReadMacInt32(XLM_GET_RESOURCE)); + ppc_cpu->get_resource(ReadMacInt32(XLM_GET_RESOURCE)); } void get_1_resource(void) { - current_cpu->get_resource(ReadMacInt32(XLM_GET_1_RESOURCE)); + ppc_cpu->get_resource(ReadMacInt32(XLM_GET_1_RESOURCE)); } void get_ind_resource(void) { - current_cpu->get_resource(ReadMacInt32(XLM_GET_IND_RESOURCE)); + ppc_cpu->get_resource(ReadMacInt32(XLM_GET_IND_RESOURCE)); } void get_1_ind_resource(void) { - current_cpu->get_resource(ReadMacInt32(XLM_GET_1_IND_RESOURCE)); + ppc_cpu->get_resource(ReadMacInt32(XLM_GET_1_IND_RESOURCE)); } void r_get_resource(void) { - current_cpu->get_resource(ReadMacInt32(XLM_R_GET_RESOURCE)); + ppc_cpu->get_resource(ReadMacInt32(XLM_R_GET_RESOURCE)); }