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 |
93 |
|
// PowerPC EmulOp to exit from emulation looop |
94 |
|
const uint32 POWERPC_EXEC_RETURN = POWERPC_EMUL_OP | 1; |
95 |
|
|
96 |
– |
// Enable interrupt routine safety checks? |
97 |
– |
#define SAFE_INTERRUPT_PPC 1 |
98 |
– |
|
96 |
|
// Enable Execute68k() safety checks? |
97 |
|
#define SAFE_EXEC_68K 1 |
98 |
|
|
139 |
|
void init_decoder(); |
140 |
|
void execute_sheep(uint32 opcode); |
141 |
|
|
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 |
– |
|
142 |
|
public: |
143 |
|
|
144 |
|
// Constructor |
174 |
|
|
175 |
|
// Handle MacOS interrupt |
176 |
|
void interrupt(uint32 entry); |
195 |
– |
void handle_interrupt(); |
177 |
|
|
178 |
|
// Make sure the SIGSEGV handler can access CPU registers |
179 |
|
friend sigsegv_return_t sigsegv_handler(sigsegv_address_t, sigsegv_address_t); |
458 |
|
} |
459 |
|
#endif |
460 |
|
|
480 |
– |
// CPU context to preserve on interrupt |
481 |
– |
sheepshaver_cpu::interrupt_context::interrupt_context(sheepshaver_cpu *_cpu, const char *_where) |
482 |
– |
{ |
483 |
– |
#if SAFE_INTERRUPT_PPC >= 2 |
484 |
– |
cpu = _cpu; |
485 |
– |
where = _where; |
486 |
– |
|
487 |
– |
// Save interrupt context |
488 |
– |
memcpy(&gpr[0], &cpu->gpr(0), sizeof(gpr)); |
489 |
– |
pc = cpu->pc(); |
490 |
– |
lr = cpu->lr(); |
491 |
– |
ctr = cpu->ctr(); |
492 |
– |
cr = cpu->get_cr(); |
493 |
– |
xer = cpu->get_xer(); |
494 |
– |
#endif |
495 |
– |
} |
496 |
– |
|
497 |
– |
sheepshaver_cpu::interrupt_context::~interrupt_context() |
498 |
– |
{ |
499 |
– |
#if SAFE_INTERRUPT_PPC >= 2 |
500 |
– |
// Check whether CPU context was preserved by interrupt |
501 |
– |
if (memcmp(&gpr[0], &cpu->gpr(0), sizeof(gpr)) != 0) { |
502 |
– |
printf("FATAL: %s: interrupt clobbers registers\n", where); |
503 |
– |
for (int i = 0; i < 32; i++) |
504 |
– |
if (gpr[i] != cpu->gpr(i)) |
505 |
– |
printf(" r%d: %08x -> %08x\n", i, gpr[i], cpu->gpr(i)); |
506 |
– |
} |
507 |
– |
if (pc != cpu->pc()) |
508 |
– |
printf("FATAL: %s: interrupt clobbers PC\n", where); |
509 |
– |
if (lr != cpu->lr()) |
510 |
– |
printf("FATAL: %s: interrupt clobbers LR\n", where); |
511 |
– |
if (ctr != cpu->ctr()) |
512 |
– |
printf("FATAL: %s: interrupt clobbers CTR\n", where); |
513 |
– |
if (cr != cpu->get_cr()) |
514 |
– |
printf("FATAL: %s: interrupt clobbers CR\n", where); |
515 |
– |
if (xer != cpu->get_xer()) |
516 |
– |
printf("FATAL: %s: interrupt clobbers XER\n", where); |
517 |
– |
#endif |
518 |
– |
} |
519 |
– |
|
461 |
|
// Handle MacOS interrupt |
462 |
|
void sheepshaver_cpu::interrupt(uint32 entry) |
463 |
|
{ |
466 |
|
const clock_t interrupt_start = clock(); |
467 |
|
#endif |
468 |
|
|
528 |
– |
#if SAFE_INTERRUPT_PPC |
529 |
– |
static int depth = 0; |
530 |
– |
if (depth != 0) |
531 |
– |
printf("FATAL: sheepshaver_cpu::interrupt() called more than once: %d\n", depth); |
532 |
– |
depth++; |
533 |
– |
#endif |
534 |
– |
|
469 |
|
// Save program counters and branch registers |
470 |
|
uint32 saved_pc = pc(); |
471 |
|
uint32 saved_lr = lr(); |
519 |
|
#if EMUL_TIME_STATS |
520 |
|
interrupt_time += (clock() - interrupt_start); |
521 |
|
#endif |
588 |
– |
|
589 |
– |
#if SAFE_INTERRUPT_PPC |
590 |
– |
depth--; |
591 |
– |
#endif |
522 |
|
} |
523 |
|
|
524 |
|
// Execute 68k routine |
918 |
|
#endif |
919 |
|
} |
920 |
|
|
921 |
< |
void sheepshaver_cpu::handle_interrupt(void) |
921 |
> |
void HandleInterrupt(powerpc_registers *r) |
922 |
|
{ |
923 |
|
#ifdef USE_SDL_VIDEO |
924 |
|
// We must fill in the events queue in the same thread that did call SDL_SetVideoMode() |
929 |
|
if (int32(ReadMacInt32(XLM_IRQ_NEST)) > 0) |
930 |
|
return; |
931 |
|
|
932 |
+ |
// Do nothing if there is no pending interrupt |
933 |
+ |
if (InterruptFlags == 0) |
934 |
+ |
return; |
935 |
+ |
|
936 |
|
// Current interrupt nest level |
937 |
|
static int interrupt_depth = 0; |
938 |
|
++interrupt_depth; |
940 |
|
interrupt_count++; |
941 |
|
#endif |
942 |
|
|
1009 |
– |
// Disable MacOS stack sniffer |
1010 |
– |
WriteMacInt32(0x110, 0); |
1011 |
– |
|
943 |
|
// Interrupt action depends on current run mode |
944 |
|
switch (ReadMacInt32(XLM_RUN_MODE)) { |
945 |
|
case MODE_68K: |
946 |
|
// 68k emulator active, trigger 68k interrupt level 1 |
947 |
|
WriteMacInt16(tswap32(kernel_data->v[0x67c >> 2]), 1); |
948 |
< |
set_cr(get_cr() | tswap32(kernel_data->v[0x674 >> 2])); |
948 |
> |
r->cr.set(r->cr.get() | tswap32(kernel_data->v[0x674 >> 2])); |
949 |
|
break; |
950 |
|
|
951 |
|
#if INTERRUPTS_IN_NATIVE_MODE |
952 |
|
case MODE_NATIVE: |
953 |
|
// 68k emulator inactive, in nanokernel? |
954 |
< |
if (gpr(1) != KernelDataAddr && interrupt_depth == 1) { |
1024 |
< |
interrupt_context ctx(this, "PowerPC mode"); |
954 |
> |
if (r->gpr[1] != KernelDataAddr && interrupt_depth == 1) { |
955 |
|
|
956 |
|
// Prepare for 68k interrupt level 1 |
957 |
|
WriteMacInt16(tswap32(kernel_data->v[0x67c >> 2]), 1); |
973 |
|
case MODE_EMUL_OP: |
974 |
|
// 68k emulator active, within EMUL_OP routine, execute 68k interrupt routine directly when interrupt level is 0 |
975 |
|
if ((ReadMacInt32(XLM_68K_R25) & 7) == 0) { |
1046 |
– |
interrupt_context ctx(this, "68k mode"); |
976 |
|
#if EMUL_TIME_STATS |
977 |
|
const clock_t interrupt_start = clock(); |
978 |
|
#endif |