| 31 |
|
#include "cpu/ppc/ppc-cpu.hpp" |
| 32 |
|
#include "cpu/ppc/ppc-operations.hpp" |
| 33 |
|
#include "cpu/ppc/ppc-instructions.hpp" |
| 34 |
+ |
#include "thunks.h" |
| 35 |
|
|
| 36 |
|
// Used for NativeOp trampolines |
| 37 |
|
#include "video.h" |
| 73 |
|
#endif |
| 74 |
|
} |
| 75 |
|
|
| 76 |
+ |
// PowerPC EmulOp to exit from emulation looop |
| 77 |
+ |
const uint32 POWERPC_EXEC_RETURN = POWERPC_EMUL_OP | 1; |
| 78 |
+ |
|
| 79 |
|
// Enable multicore (main/interrupts) cpu emulation? |
| 80 |
|
#define MULTICORE_CPU (ASYNC_IRQ ? 1 : 0) |
| 81 |
|
|
| 97 |
|
// SIGSEGV handler |
| 98 |
|
static sigsegv_return_t sigsegv_handler(sigsegv_address_t, sigsegv_address_t); |
| 99 |
|
|
| 100 |
+ |
// JIT Compiler enabled? |
| 101 |
+ |
static inline bool enable_jit_p() |
| 102 |
+ |
{ |
| 103 |
+ |
return PrefsFindBool("jit"); |
| 104 |
+ |
} |
| 105 |
+ |
|
| 106 |
|
|
| 107 |
|
/** |
| 108 |
|
* PowerPC emulator glue with special 'sheep' opcodes |
| 128 |
|
uint32 get_cr() const { return cr().get(); } |
| 129 |
|
void set_cr(uint32 v) { cr().set(v); } |
| 130 |
|
|
| 121 |
– |
// Execution loop |
| 122 |
– |
void execute(uint32 entry, bool enable_cache = false); |
| 123 |
– |
|
| 131 |
|
// Execute 68k routine |
| 132 |
|
void execute_68k(uint32 entry, M68kRegisters *r); |
| 133 |
|
|
| 160 |
|
lazy_allocator< sheepshaver_cpu > allocator_helper< sheepshaver_cpu, lazy_allocator >::allocator; |
| 161 |
|
|
| 162 |
|
sheepshaver_cpu::sheepshaver_cpu() |
| 163 |
< |
: powerpc_cpu() |
| 163 |
> |
: powerpc_cpu(enable_jit_p()) |
| 164 |
|
{ |
| 165 |
|
init_decoder(); |
| 166 |
|
} |
| 251 |
|
} |
| 252 |
|
} |
| 253 |
|
|
| 247 |
– |
// Execution loop |
| 248 |
– |
void sheepshaver_cpu::execute(uint32 entry, bool enable_cache) |
| 249 |
– |
{ |
| 250 |
– |
powerpc_cpu::execute(entry, enable_cache); |
| 251 |
– |
} |
| 252 |
– |
|
| 254 |
|
// Handle MacOS interrupt |
| 255 |
|
void sheepshaver_cpu::interrupt(uint32 entry) |
| 256 |
|
{ |
| 268 |
|
#endif |
| 269 |
|
|
| 270 |
|
// Initialize stack pointer to SheepShaver alternate stack base |
| 271 |
< |
gpr(1) = SheepStack1Base - 64; |
| 271 |
> |
SheepArray<64> stack_area; |
| 272 |
> |
gpr(1) = stack_area.addr(); |
| 273 |
|
|
| 274 |
|
// Build trampoline to return from interrupt |
| 275 |
< |
uint32 trampoline[] = { htonl(POWERPC_EMUL_OP | 1) }; |
| 275 |
> |
SheepVar32 trampoline = POWERPC_EXEC_RETURN; |
| 276 |
|
|
| 277 |
|
// Prepare registers for nanokernel interrupt routine |
| 278 |
|
kernel_data->v[0x004 >> 2] = htonl(gpr(1)); |
| 291 |
|
gpr(1) = KernelDataAddr; |
| 292 |
|
gpr(7) = ntohl(kernel_data->v[0x660 >> 2]); |
| 293 |
|
gpr(8) = 0; |
| 294 |
< |
gpr(10) = (uint32)trampoline; |
| 295 |
< |
gpr(12) = (uint32)trampoline; |
| 294 |
> |
gpr(10) = trampoline.addr(); |
| 295 |
> |
gpr(12) = trampoline.addr(); |
| 296 |
|
gpr(13) = get_cr(); |
| 297 |
|
|
| 298 |
|
// rlwimi. r7,r7,8,0,0 |
| 429 |
|
uint32 saved_ctr= ctr(); |
| 430 |
|
|
| 431 |
|
// Build trampoline with EXEC_RETURN |
| 432 |
< |
uint32 trampoline[] = { htonl(POWERPC_EMUL_OP | 1) }; |
| 433 |
< |
lr() = (uint32)trampoline; |
| 432 |
> |
SheepVar32 trampoline = POWERPC_EXEC_RETURN; |
| 433 |
> |
lr() = trampoline.addr(); |
| 434 |
|
|
| 435 |
|
gpr(1) -= 64; // Create stack frame |
| 436 |
|
uint32 proc = ReadMacInt32(tvect); // Get routine address |
| 474 |
|
// Save branch registers |
| 475 |
|
uint32 saved_lr = lr(); |
| 476 |
|
|
| 477 |
< |
const uint32 trampoline[] = { htonl(POWERPC_EMUL_OP | 1) }; |
| 478 |
< |
lr() = (uint32)trampoline; |
| 477 |
> |
SheepVar32 trampoline = POWERPC_EXEC_RETURN; |
| 478 |
> |
WriteMacInt32(trampoline.addr(), POWERPC_EXEC_RETURN); |
| 479 |
> |
lr() = trampoline.addr(); |
| 480 |
|
|
| 481 |
|
execute(entry); |
| 482 |
|
|
| 689 |
|
current_cpu->start_log(); |
| 690 |
|
#endif |
| 691 |
|
// start emulation loop and enable code translation or caching |
| 692 |
< |
current_cpu->execute(entry, true); |
| 692 |
> |
current_cpu->execute(entry); |
| 693 |
|
} |
| 694 |
|
|
| 695 |
|
/* |
| 784 |
|
if (InterruptFlags & INTFLAG_VIA) { |
| 785 |
|
ClearInterruptFlag(INTFLAG_VIA); |
| 786 |
|
ADBInterrupt(); |
| 787 |
< |
ExecutePPC(VideoVBL); |
| 787 |
> |
ExecuteNative(NATIVE_VIDEO_VBL); |
| 788 |
|
} |
| 789 |
|
} |
| 790 |
|
#endif |
| 794 |
|
} |
| 795 |
|
} |
| 796 |
|
|
| 794 |
– |
/* |
| 795 |
– |
* Execute NATIVE_OP opcode (called by PowerPC emulator) |
| 796 |
– |
*/ |
| 797 |
– |
|
| 798 |
– |
#define POWERPC_NATIVE_OP_INIT(LR, OP) \ |
| 799 |
– |
tswap32(POWERPC_EMUL_OP | ((LR) << 11) | (((uint32)OP) << 6) | 2) |
| 800 |
– |
|
| 801 |
– |
// FIXME: Make sure 32-bit relocations are used |
| 802 |
– |
const uint32 NativeOpTable[NATIVE_OP_MAX] = { |
| 803 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_PATCH_NAME_REGISTRY), |
| 804 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_VIDEO_INSTALL_ACCEL), |
| 805 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_VIDEO_VBL), |
| 806 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_VIDEO_DO_DRIVER_IO), |
| 807 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_ETHER_IRQ), |
| 808 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_ETHER_INIT), |
| 809 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_ETHER_TERM), |
| 810 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_ETHER_OPEN), |
| 811 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_ETHER_CLOSE), |
| 812 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_ETHER_WPUT), |
| 813 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_ETHER_RSRV), |
| 814 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_SERIAL_NOTHING), |
| 815 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_SERIAL_OPEN), |
| 816 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_SERIAL_PRIME_IN), |
| 817 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_SERIAL_PRIME_OUT), |
| 818 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_SERIAL_CONTROL), |
| 819 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_SERIAL_STATUS), |
| 820 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_SERIAL_CLOSE), |
| 821 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_GET_RESOURCE), |
| 822 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_GET_1_RESOURCE), |
| 823 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_GET_IND_RESOURCE), |
| 824 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_GET_1_IND_RESOURCE), |
| 825 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_R_GET_RESOURCE), |
| 826 |
– |
POWERPC_NATIVE_OP_INIT(0, NATIVE_DISABLE_INTERRUPT), |
| 827 |
– |
POWERPC_NATIVE_OP_INIT(0, NATIVE_ENABLE_INTERRUPT), |
| 828 |
– |
POWERPC_NATIVE_OP_INIT(1, NATIVE_MAKE_EXECUTABLE), |
| 829 |
– |
}; |
| 830 |
– |
|
| 797 |
|
static void get_resource(void); |
| 798 |
|
static void get_1_resource(void); |
| 799 |
|
static void get_ind_resource(void); |
| 908 |
|
} |
| 909 |
|
|
| 910 |
|
/* |
| 945 |
– |
* Execute native subroutine (LR must contain return address) |
| 946 |
– |
*/ |
| 947 |
– |
|
| 948 |
– |
void ExecuteNative(int selector) |
| 949 |
– |
{ |
| 950 |
– |
uint32 tvect[2]; |
| 951 |
– |
tvect[0] = tswap32(POWERPC_NATIVE_OP_FUNC(selector)); |
| 952 |
– |
tvect[1] = 0; // Fake TVECT |
| 953 |
– |
RoutineDescriptor desc = BUILD_PPC_ROUTINE_DESCRIPTOR(0, tvect); |
| 954 |
– |
M68kRegisters r; |
| 955 |
– |
Execute68k((uint32)&desc, &r); |
| 956 |
– |
} |
| 957 |
– |
|
| 958 |
– |
/* |
| 911 |
|
* Execute 68k subroutine (must be ended with EXEC_RETURN) |
| 912 |
|
* This must only be called by the emul_thread when in EMUL_OP mode |
| 913 |
|
* r->a[7] is unused, the routine runs on the caller's stack |
| 925 |
|
|
| 926 |
|
void Execute68kTrap(uint16 trap, M68kRegisters *r) |
| 927 |
|
{ |
| 928 |
< |
uint16 proc[2]; |
| 929 |
< |
proc[0] = htons(trap); |
| 930 |
< |
proc[1] = htons(M68K_RTS); |
| 931 |
< |
Execute68k((uint32)proc, r); |
| 928 |
> |
SheepVar proc_var(4); |
| 929 |
> |
uint32 proc = proc_var.addr(); |
| 930 |
> |
WriteMacInt16(proc, trap); |
| 931 |
> |
WriteMacInt16(proc + 2, M68K_RTS); |
| 932 |
> |
Execute68k(proc, r); |
| 933 |
|
} |
| 934 |
|
|
| 935 |
|
/* |
