1 |
|
/* |
2 |
|
* sheepshaver_glue.cpp - Glue Kheperix CPU to SheepShaver CPU engine interface |
3 |
|
* |
4 |
< |
* SheepShaver (C) 1997-2004 Christian Bauer and Marc Hellwig |
4 |
> |
* SheepShaver (C) 1997-2005 Christian Bauer and Marc Hellwig |
5 |
|
* |
6 |
|
* This program is free software; you can redistribute it and/or modify |
7 |
|
* it under the terms of the GNU General Public License as published by |
89 |
|
|
90 |
|
// From rsrc_patches.cpp |
91 |
|
extern "C" void check_load_invoc(uint32 type, int16 id, uint32 h); |
92 |
+ |
extern "C" void named_check_load_invoc(uint32 type, uint32 name, uint32 h); |
93 |
|
|
94 |
|
// PowerPC EmulOp to exit from emulation looop |
95 |
|
const uint32 POWERPC_EXEC_RETURN = POWERPC_EMUL_OP | 1; |
96 |
|
|
96 |
– |
// Enable interrupt routine safety checks? |
97 |
– |
#define SAFE_INTERRUPT_PPC 1 |
98 |
– |
|
97 |
|
// Enable Execute68k() safety checks? |
98 |
|
#define SAFE_EXEC_68K 1 |
99 |
|
|
140 |
|
void init_decoder(); |
141 |
|
void execute_sheep(uint32 opcode); |
142 |
|
|
145 |
– |
// CPU context to preserve on interrupt |
146 |
– |
class interrupt_context { |
147 |
– |
uint32 gpr[32]; |
148 |
– |
uint32 pc; |
149 |
– |
uint32 lr; |
150 |
– |
uint32 ctr; |
151 |
– |
uint32 cr; |
152 |
– |
uint32 xer; |
153 |
– |
sheepshaver_cpu *cpu; |
154 |
– |
const char *where; |
155 |
– |
public: |
156 |
– |
interrupt_context(sheepshaver_cpu *_cpu, const char *_where); |
157 |
– |
~interrupt_context(); |
158 |
– |
}; |
159 |
– |
|
143 |
|
public: |
144 |
|
|
145 |
|
// Constructor |
175 |
|
|
176 |
|
// Handle MacOS interrupt |
177 |
|
void interrupt(uint32 entry); |
195 |
– |
void handle_interrupt(); |
178 |
|
|
179 |
|
// Make sure the SIGSEGV handler can access CPU registers |
180 |
|
friend sigsegv_return_t sigsegv_handler(sigsegv_address_t, sigsegv_address_t); |
181 |
|
}; |
182 |
|
|
201 |
– |
// Memory allocator returning areas aligned on 16-byte boundaries |
202 |
– |
void *operator new(size_t size) |
203 |
– |
{ |
204 |
– |
void *p; |
205 |
– |
|
206 |
– |
#if defined(HAVE_POSIX_MEMALIGN) |
207 |
– |
if (posix_memalign(&p, 16, size) != 0) |
208 |
– |
throw std::bad_alloc(); |
209 |
– |
#elif defined(HAVE_MEMALIGN) |
210 |
– |
p = memalign(16, size); |
211 |
– |
#elif defined(HAVE_VALLOC) |
212 |
– |
p = valloc(size); // page-aligned! |
213 |
– |
#else |
214 |
– |
/* XXX: handle padding ourselves */ |
215 |
– |
p = malloc(size); |
216 |
– |
#endif |
217 |
– |
|
218 |
– |
return p; |
219 |
– |
} |
220 |
– |
|
221 |
– |
void operator delete(void *p) |
222 |
– |
{ |
223 |
– |
#if defined(HAVE_MEMALIGN) || defined(HAVE_VALLOC) |
224 |
– |
#if defined(__GLIBC__) |
225 |
– |
// this is known to work only with GNU libc |
226 |
– |
free(p); |
227 |
– |
#endif |
228 |
– |
#else |
229 |
– |
free(p); |
230 |
– |
#endif |
231 |
– |
} |
232 |
– |
|
183 |
|
sheepshaver_cpu::sheepshaver_cpu() |
184 |
|
: powerpc_cpu(enable_jit_p()) |
185 |
|
{ |
228 |
|
for (int i = 0; i < 7; i++) |
229 |
|
r68.a[i] = gpr(16 + i); |
230 |
|
r68.a[7] = gpr(1); |
231 |
< |
uint32 saved_cr = get_cr() & CR_field<2>::mask(); |
231 |
> |
uint32 saved_cr = get_cr() & 0xff9fffff; // mask_operand::compute(11, 8) |
232 |
|
uint32 saved_xer = get_xer(); |
233 |
|
EmulOp(&r68, gpr(24), emul_op); |
234 |
|
set_cr(saved_cr); |
344 |
|
dg.gen_invoke_T0_T1_T2((void (*)(uint32, uint32, uint32))check_load_invoc); |
345 |
|
status = COMPILE_CODE_OK; |
346 |
|
break; |
347 |
+ |
case NATIVE_NAMED_CHECK_LOAD_INVOC: |
348 |
+ |
dg.gen_load_T0_GPR(3); |
349 |
+ |
dg.gen_load_T1_GPR(4); |
350 |
+ |
dg.gen_load_T2_GPR(5); |
351 |
+ |
dg.gen_invoke_T0_T1_T2((void (*)(uint32, uint32, uint32))named_check_load_invoc); |
352 |
+ |
status = COMPILE_CODE_OK; |
353 |
+ |
break; |
354 |
|
#endif |
355 |
< |
case NATIVE_BITBLT: |
355 |
> |
case NATIVE_NQD_BITBLT: |
356 |
|
dg.gen_load_T0_GPR(3); |
357 |
|
dg.gen_invoke_T0((void (*)(uint32))NQD_bitblt); |
358 |
|
status = COMPILE_CODE_OK; |
359 |
|
break; |
360 |
< |
case NATIVE_INVRECT: |
360 |
> |
case NATIVE_NQD_INVRECT: |
361 |
|
dg.gen_load_T0_GPR(3); |
362 |
|
dg.gen_invoke_T0((void (*)(uint32))NQD_invrect); |
363 |
|
status = COMPILE_CODE_OK; |
364 |
|
break; |
365 |
< |
case NATIVE_FILLRECT: |
365 |
> |
case NATIVE_NQD_FILLRECT: |
366 |
|
dg.gen_load_T0_GPR(3); |
367 |
|
dg.gen_invoke_T0((void (*)(uint32))NQD_fillrect); |
368 |
|
status = COMPILE_CODE_OK; |
430 |
|
} |
431 |
|
#endif |
432 |
|
|
476 |
– |
// CPU context to preserve on interrupt |
477 |
– |
sheepshaver_cpu::interrupt_context::interrupt_context(sheepshaver_cpu *_cpu, const char *_where) |
478 |
– |
{ |
479 |
– |
#if SAFE_INTERRUPT_PPC >= 2 |
480 |
– |
cpu = _cpu; |
481 |
– |
where = _where; |
482 |
– |
|
483 |
– |
// Save interrupt context |
484 |
– |
memcpy(&gpr[0], &cpu->gpr(0), sizeof(gpr)); |
485 |
– |
pc = cpu->pc(); |
486 |
– |
lr = cpu->lr(); |
487 |
– |
ctr = cpu->ctr(); |
488 |
– |
cr = cpu->get_cr(); |
489 |
– |
xer = cpu->get_xer(); |
490 |
– |
#endif |
491 |
– |
} |
492 |
– |
|
493 |
– |
sheepshaver_cpu::interrupt_context::~interrupt_context() |
494 |
– |
{ |
495 |
– |
#if SAFE_INTERRUPT_PPC >= 2 |
496 |
– |
// Check whether CPU context was preserved by interrupt |
497 |
– |
if (memcmp(&gpr[0], &cpu->gpr(0), sizeof(gpr)) != 0) { |
498 |
– |
printf("FATAL: %s: interrupt clobbers registers\n", where); |
499 |
– |
for (int i = 0; i < 32; i++) |
500 |
– |
if (gpr[i] != cpu->gpr(i)) |
501 |
– |
printf(" r%d: %08x -> %08x\n", i, gpr[i], cpu->gpr(i)); |
502 |
– |
} |
503 |
– |
if (pc != cpu->pc()) |
504 |
– |
printf("FATAL: %s: interrupt clobbers PC\n", where); |
505 |
– |
if (lr != cpu->lr()) |
506 |
– |
printf("FATAL: %s: interrupt clobbers LR\n", where); |
507 |
– |
if (ctr != cpu->ctr()) |
508 |
– |
printf("FATAL: %s: interrupt clobbers CTR\n", where); |
509 |
– |
if (cr != cpu->get_cr()) |
510 |
– |
printf("FATAL: %s: interrupt clobbers CR\n", where); |
511 |
– |
if (xer != cpu->get_xer()) |
512 |
– |
printf("FATAL: %s: interrupt clobbers XER\n", where); |
513 |
– |
#endif |
514 |
– |
} |
515 |
– |
|
433 |
|
// Handle MacOS interrupt |
434 |
|
void sheepshaver_cpu::interrupt(uint32 entry) |
435 |
|
{ |
438 |
|
const clock_t interrupt_start = clock(); |
439 |
|
#endif |
440 |
|
|
524 |
– |
#if SAFE_INTERRUPT_PPC |
525 |
– |
static int depth = 0; |
526 |
– |
if (depth != 0) |
527 |
– |
printf("FATAL: sheepshaver_cpu::interrupt() called more than once: %d\n", depth); |
528 |
– |
depth++; |
529 |
– |
#endif |
530 |
– |
|
441 |
|
// Save program counters and branch registers |
442 |
|
uint32 saved_pc = pc(); |
443 |
|
uint32 saved_lr = lr(); |
491 |
|
#if EMUL_TIME_STATS |
492 |
|
interrupt_time += (clock() - interrupt_start); |
493 |
|
#endif |
584 |
– |
|
585 |
– |
#if SAFE_INTERRUPT_PPC |
586 |
– |
depth--; |
587 |
– |
#endif |
494 |
|
} |
495 |
|
|
496 |
|
// Execute 68k routine |
768 |
|
#error "FIXME: You don't have the capability to skip instruction within signal handlers" |
769 |
|
#endif |
770 |
|
|
771 |
< |
printf("SIGSEGV\n"); |
772 |
< |
printf(" pc %p\n", fault_instruction); |
773 |
< |
printf(" ea %p\n", fault_address); |
771 |
> |
fprintf(stderr, "SIGSEGV\n"); |
772 |
> |
fprintf(stderr, " pc %p\n", fault_instruction); |
773 |
> |
fprintf(stderr, " ea %p\n", fault_address); |
774 |
|
dump_registers(); |
775 |
|
ppc_cpu->dump_log(); |
776 |
|
enter_mon(); |
834 |
|
#endif |
835 |
|
|
836 |
|
delete ppc_cpu; |
837 |
+ |
ppc_cpu = NULL; |
838 |
|
} |
839 |
|
|
840 |
|
#if PPC_ENABLE_JIT && PPC_REENTRANT_JIT |
882 |
|
|
883 |
|
void TriggerInterrupt(void) |
884 |
|
{ |
885 |
+ |
idle_resume(); |
886 |
|
#if 0 |
887 |
|
WriteMacInt32(0x16a, ReadMacInt32(0x16a) + 1); |
888 |
|
#else |
892 |
|
#endif |
893 |
|
} |
894 |
|
|
895 |
< |
void sheepshaver_cpu::handle_interrupt(void) |
895 |
> |
void HandleInterrupt(powerpc_registers *r) |
896 |
|
{ |
897 |
|
#ifdef USE_SDL_VIDEO |
898 |
|
// We must fill in the events queue in the same thread that did call SDL_SetVideoMode() |
903 |
|
if (int32(ReadMacInt32(XLM_IRQ_NEST)) > 0) |
904 |
|
return; |
905 |
|
|
906 |
< |
// Current interrupt nest level |
999 |
< |
static int interrupt_depth = 0; |
1000 |
< |
++interrupt_depth; |
906 |
> |
// Update interrupt count |
907 |
|
#if EMUL_TIME_STATS |
908 |
|
interrupt_count++; |
909 |
|
#endif |
910 |
|
|
1005 |
– |
// Disable MacOS stack sniffer |
1006 |
– |
WriteMacInt32(0x110, 0); |
1007 |
– |
|
911 |
|
// Interrupt action depends on current run mode |
912 |
|
switch (ReadMacInt32(XLM_RUN_MODE)) { |
913 |
|
case MODE_68K: |
914 |
|
// 68k emulator active, trigger 68k interrupt level 1 |
915 |
|
WriteMacInt16(tswap32(kernel_data->v[0x67c >> 2]), 1); |
916 |
< |
set_cr(get_cr() | tswap32(kernel_data->v[0x674 >> 2])); |
916 |
> |
r->cr.set(r->cr.get() | tswap32(kernel_data->v[0x674 >> 2])); |
917 |
|
break; |
918 |
|
|
919 |
|
#if INTERRUPTS_IN_NATIVE_MODE |
920 |
|
case MODE_NATIVE: |
921 |
|
// 68k emulator inactive, in nanokernel? |
922 |
< |
if (gpr(1) != KernelDataAddr && interrupt_depth == 1) { |
1020 |
< |
interrupt_context ctx(this, "PowerPC mode"); |
922 |
> |
if (r->gpr[1] != KernelDataAddr) { |
923 |
|
|
924 |
|
// Prepare for 68k interrupt level 1 |
925 |
|
WriteMacInt16(tswap32(kernel_data->v[0x67c >> 2]), 1); |
941 |
|
case MODE_EMUL_OP: |
942 |
|
// 68k emulator active, within EMUL_OP routine, execute 68k interrupt routine directly when interrupt level is 0 |
943 |
|
if ((ReadMacInt32(XLM_68K_R25) & 7) == 0) { |
1042 |
– |
interrupt_context ctx(this, "68k mode"); |
944 |
|
#if EMUL_TIME_STATS |
945 |
|
const clock_t interrupt_start = clock(); |
946 |
|
#endif |
977 |
|
break; |
978 |
|
#endif |
979 |
|
} |
1079 |
– |
|
1080 |
– |
// We are done with this interrupt |
1081 |
– |
--interrupt_depth; |
980 |
|
} |
981 |
|
|
1084 |
– |
static void get_resource(void); |
1085 |
– |
static void get_1_resource(void); |
1086 |
– |
static void get_ind_resource(void); |
1087 |
– |
static void get_1_ind_resource(void); |
1088 |
– |
static void r_get_resource(void); |
1089 |
– |
|
982 |
|
// Execute NATIVE_OP routine |
983 |
|
void sheepshaver_cpu::execute_native_op(uint32 selector) |
984 |
|
{ |
1000 |
|
case NATIVE_VIDEO_DO_DRIVER_IO: |
1001 |
|
gpr(3) = (int32)(int16)VideoDoDriverIO(gpr(3), gpr(4), gpr(5), gpr(6), gpr(7)); |
1002 |
|
break; |
1003 |
< |
#ifdef WORDS_BIGENDIAN |
1003 |
> |
case NATIVE_ETHER_AO_GET_HWADDR: |
1004 |
> |
AO_get_ethernet_address(gpr(3)); |
1005 |
> |
break; |
1006 |
> |
case NATIVE_ETHER_AO_ADD_MULTI: |
1007 |
> |
AO_enable_multicast(gpr(3)); |
1008 |
> |
break; |
1009 |
> |
case NATIVE_ETHER_AO_DEL_MULTI: |
1010 |
> |
AO_disable_multicast(gpr(3)); |
1011 |
> |
break; |
1012 |
> |
case NATIVE_ETHER_AO_SEND_PACKET: |
1013 |
> |
AO_transmit_packet(gpr(3)); |
1014 |
> |
break; |
1015 |
|
case NATIVE_ETHER_IRQ: |
1016 |
|
EtherIRQ(); |
1017 |
|
break; |
1033 |
|
case NATIVE_ETHER_RSRV: |
1034 |
|
gpr(3) = ether_rsrv((queue_t *)gpr(3)); |
1035 |
|
break; |
1036 |
< |
#else |
1134 |
< |
case NATIVE_ETHER_INIT: |
1135 |
< |
// FIXME: needs more complicated thunks |
1136 |
< |
gpr(3) = false; |
1137 |
< |
break; |
1138 |
< |
#endif |
1139 |
< |
case NATIVE_SYNC_HOOK: |
1036 |
> |
case NATIVE_NQD_SYNC_HOOK: |
1037 |
|
gpr(3) = NQD_sync_hook(gpr(3)); |
1038 |
|
break; |
1039 |
< |
case NATIVE_BITBLT_HOOK: |
1039 |
> |
case NATIVE_NQD_BITBLT_HOOK: |
1040 |
|
gpr(3) = NQD_bitblt_hook(gpr(3)); |
1041 |
|
break; |
1042 |
< |
case NATIVE_BITBLT: |
1042 |
> |
case NATIVE_NQD_BITBLT: |
1043 |
|
NQD_bitblt(gpr(3)); |
1044 |
|
break; |
1045 |
< |
case NATIVE_FILLRECT_HOOK: |
1045 |
> |
case NATIVE_NQD_FILLRECT_HOOK: |
1046 |
|
gpr(3) = NQD_fillrect_hook(gpr(3)); |
1047 |
|
break; |
1048 |
< |
case NATIVE_INVRECT: |
1048 |
> |
case NATIVE_NQD_INVRECT: |
1049 |
|
NQD_invrect(gpr(3)); |
1050 |
|
break; |
1051 |
< |
case NATIVE_FILLRECT: |
1051 |
> |
case NATIVE_NQD_FILLRECT: |
1052 |
|
NQD_fillrect(gpr(3)); |
1053 |
|
break; |
1054 |
|
case NATIVE_SERIAL_NOTHING: |
1072 |
|
break; |
1073 |
|
} |
1074 |
|
case NATIVE_GET_RESOURCE: |
1075 |
+ |
get_resource(ReadMacInt32(XLM_GET_RESOURCE)); |
1076 |
+ |
break; |
1077 |
|
case NATIVE_GET_1_RESOURCE: |
1078 |
+ |
get_resource(ReadMacInt32(XLM_GET_1_RESOURCE)); |
1079 |
+ |
break; |
1080 |
|
case NATIVE_GET_IND_RESOURCE: |
1081 |
+ |
get_resource(ReadMacInt32(XLM_GET_IND_RESOURCE)); |
1082 |
+ |
break; |
1083 |
|
case NATIVE_GET_1_IND_RESOURCE: |
1084 |
< |
case NATIVE_R_GET_RESOURCE: { |
1085 |
< |
typedef void (*GetResourceCallback)(void); |
1086 |
< |
static const GetResourceCallback get_resource_callbacks[] = { |
1087 |
< |
::get_resource, |
1185 |
< |
::get_1_resource, |
1186 |
< |
::get_ind_resource, |
1187 |
< |
::get_1_ind_resource, |
1188 |
< |
::r_get_resource |
1189 |
< |
}; |
1190 |
< |
get_resource_callbacks[selector - NATIVE_GET_RESOURCE](); |
1084 |
> |
get_resource(ReadMacInt32(XLM_GET_1_IND_RESOURCE)); |
1085 |
> |
break; |
1086 |
> |
case NATIVE_R_GET_RESOURCE: |
1087 |
> |
get_resource(ReadMacInt32(XLM_R_GET_RESOURCE)); |
1088 |
|
break; |
1192 |
– |
} |
1089 |
|
case NATIVE_MAKE_EXECUTABLE: |
1090 |
|
MakeExecutable(0, gpr(4), gpr(5)); |
1091 |
|
break; |
1092 |
|
case NATIVE_CHECK_LOAD_INVOC: |
1093 |
|
check_load_invoc(gpr(3), gpr(4), gpr(5)); |
1094 |
|
break; |
1095 |
+ |
case NATIVE_NAMED_CHECK_LOAD_INVOC: |
1096 |
+ |
named_check_load_invoc(gpr(3), gpr(4), gpr(5)); |
1097 |
+ |
break; |
1098 |
|
default: |
1099 |
|
printf("FATAL: NATIVE_OP called with bogus selector %d\n", selector); |
1100 |
|
QuitEmulator(); |
1181 |
|
const uint32 args[] = { arg1, arg2, arg3, arg4, arg5, arg6, arg7 }; |
1182 |
|
return ppc_cpu->execute_macos_code(tvect, sizeof(args)/sizeof(args[0]), args); |
1183 |
|
} |
1285 |
– |
|
1286 |
– |
/* |
1287 |
– |
* Resource Manager thunks |
1288 |
– |
*/ |
1289 |
– |
|
1290 |
– |
void get_resource(void) |
1291 |
– |
{ |
1292 |
– |
ppc_cpu->get_resource(ReadMacInt32(XLM_GET_RESOURCE)); |
1293 |
– |
} |
1294 |
– |
|
1295 |
– |
void get_1_resource(void) |
1296 |
– |
{ |
1297 |
– |
ppc_cpu->get_resource(ReadMacInt32(XLM_GET_1_RESOURCE)); |
1298 |
– |
} |
1299 |
– |
|
1300 |
– |
void get_ind_resource(void) |
1301 |
– |
{ |
1302 |
– |
ppc_cpu->get_resource(ReadMacInt32(XLM_GET_IND_RESOURCE)); |
1303 |
– |
} |
1304 |
– |
|
1305 |
– |
void get_1_ind_resource(void) |
1306 |
– |
{ |
1307 |
– |
ppc_cpu->get_resource(ReadMacInt32(XLM_GET_1_IND_RESOURCE)); |
1308 |
– |
} |
1309 |
– |
|
1310 |
– |
void r_get_resource(void) |
1311 |
– |
{ |
1312 |
– |
ppc_cpu->get_resource(ReadMacInt32(XLM_R_GET_RESOURCE)); |
1313 |
– |
} |