| 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 |
| 42 |
|
|
| 43 |
|
#include <stdio.h> |
| 44 |
|
#include <stdlib.h> |
| 45 |
+ |
#ifdef HAVE_MALLOC_H |
| 46 |
+ |
#include <malloc.h> |
| 47 |
+ |
#endif |
| 48 |
+ |
|
| 49 |
+ |
#ifdef USE_SDL_VIDEO |
| 50 |
+ |
#include <SDL_events.h> |
| 51 |
+ |
#endif |
| 52 |
|
|
| 53 |
|
#if ENABLE_MON |
| 54 |
|
#include "mon.h" |
| 59 |
|
#include "debug.h" |
| 60 |
|
|
| 61 |
|
// Emulation time statistics |
| 62 |
< |
#define EMUL_TIME_STATS 1 |
| 62 |
> |
#ifndef EMUL_TIME_STATS |
| 63 |
> |
#define EMUL_TIME_STATS 0 |
| 64 |
> |
#endif |
| 65 |
|
|
| 66 |
|
#if EMUL_TIME_STATS |
| 67 |
|
static clock_t emul_start_time; |
| 68 |
< |
static uint32 interrupt_count = 0; |
| 68 |
> |
static uint32 interrupt_count = 0, ppc_interrupt_count = 0; |
| 69 |
|
static clock_t interrupt_time = 0; |
| 70 |
|
static uint32 exec68k_count = 0; |
| 71 |
|
static clock_t exec68k_time = 0; |
| 93 |
|
// PowerPC EmulOp to exit from emulation looop |
| 94 |
|
const uint32 POWERPC_EXEC_RETURN = POWERPC_EMUL_OP | 1; |
| 95 |
|
|
| 87 |
– |
// Enable interrupt routine safety checks? |
| 88 |
– |
#define SAFE_INTERRUPT_PPC 1 |
| 89 |
– |
|
| 96 |
|
// Enable Execute68k() safety checks? |
| 97 |
|
#define SAFE_EXEC_68K 1 |
| 98 |
|
|
| 105 |
|
// Interrupts in native mode? |
| 106 |
|
#define INTERRUPTS_IN_NATIVE_MODE 1 |
| 107 |
|
|
| 102 |
– |
// Enable native EMUL_OPs to be run without a mode switch |
| 103 |
– |
#define ENABLE_NATIVE_EMUL_OP 1 |
| 104 |
– |
|
| 108 |
|
// Pointer to Kernel Data |
| 109 |
< |
static KernelData * const kernel_data = (KernelData *)KERNEL_DATA_BASE; |
| 109 |
> |
static KernelData * kernel_data; |
| 110 |
|
|
| 111 |
|
// SIGSEGV handler |
| 112 |
< |
static sigsegv_return_t sigsegv_handler(sigsegv_address_t, sigsegv_address_t); |
| 112 |
> |
sigsegv_return_t sigsegv_handler(sigsegv_address_t, sigsegv_address_t); |
| 113 |
|
|
| 114 |
|
#if PPC_ENABLE_JIT && PPC_REENTRANT_JIT |
| 115 |
|
// Special trampolines for EmulOp and NativeOp |
| 139 |
|
void init_decoder(); |
| 140 |
|
void execute_sheep(uint32 opcode); |
| 141 |
|
|
| 139 |
– |
// Filter out EMUL_OP routines that only call native code |
| 140 |
– |
bool filter_execute_emul_op(uint32 emul_op); |
| 141 |
– |
|
| 142 |
– |
// "Native" EMUL_OP routines |
| 143 |
– |
void execute_emul_op_microseconds(); |
| 144 |
– |
void execute_emul_op_idle_time_1(); |
| 145 |
– |
void execute_emul_op_idle_time_2(); |
| 146 |
– |
|
| 147 |
– |
// CPU context to preserve on interrupt |
| 148 |
– |
class interrupt_context { |
| 149 |
– |
uint32 gpr[32]; |
| 150 |
– |
uint32 pc; |
| 151 |
– |
uint32 lr; |
| 152 |
– |
uint32 ctr; |
| 153 |
– |
uint32 cr; |
| 154 |
– |
uint32 xer; |
| 155 |
– |
sheepshaver_cpu *cpu; |
| 156 |
– |
const char *where; |
| 157 |
– |
public: |
| 158 |
– |
interrupt_context(sheepshaver_cpu *_cpu, const char *_where); |
| 159 |
– |
~interrupt_context(); |
| 160 |
– |
}; |
| 161 |
– |
|
| 142 |
|
public: |
| 143 |
|
|
| 144 |
|
// Constructor |
| 165 |
|
// Execute MacOS/PPC code |
| 166 |
|
uint32 execute_macos_code(uint32 tvect, int nargs, uint32 const *args); |
| 167 |
|
|
| 168 |
+ |
#if PPC_ENABLE_JIT |
| 169 |
|
// Compile one instruction |
| 170 |
|
virtual int compile1(codegen_context_t & cg_context); |
| 171 |
< |
|
| 171 |
> |
#endif |
| 172 |
|
// Resource manager thunk |
| 173 |
|
void get_resource(uint32 old_get_resource); |
| 174 |
|
|
| 175 |
|
// Handle MacOS interrupt |
| 176 |
|
void interrupt(uint32 entry); |
| 196 |
– |
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); |
| 180 |
+ |
|
| 181 |
+ |
// Memory allocator returning areas aligned on 16-byte boundaries |
| 182 |
+ |
void *operator new(size_t size); |
| 183 |
+ |
void operator delete(void *p); |
| 184 |
|
}; |
| 185 |
|
|
| 186 |
|
// Memory allocator returning areas aligned on 16-byte boundaries |
| 187 |
< |
void *operator new(size_t size) |
| 187 |
> |
void *sheepshaver_cpu::operator new(size_t size) |
| 188 |
|
{ |
| 189 |
|
void *p; |
| 190 |
|
|
| 203 |
|
return p; |
| 204 |
|
} |
| 205 |
|
|
| 206 |
< |
void operator delete(void *p) |
| 206 |
> |
void sheepshaver_cpu::operator delete(void *p) |
| 207 |
|
{ |
| 208 |
|
#if defined(HAVE_MEMALIGN) || defined(HAVE_VALLOC) |
| 209 |
|
#if defined(__GLIBC__) |
| 252 |
|
typedef bit_field< 20, 25 > NATIVE_OP_field; |
| 253 |
|
typedef bit_field< 26, 31 > EMUL_OP_field; |
| 254 |
|
|
| 271 |
– |
// "Native" EMUL_OP routines |
| 272 |
– |
#define GPR_A(REG) gpr(16 + (REG)) |
| 273 |
– |
#define GPR_D(REG) gpr( 8 + (REG)) |
| 274 |
– |
|
| 275 |
– |
void sheepshaver_cpu::execute_emul_op_microseconds() |
| 276 |
– |
{ |
| 277 |
– |
Microseconds(GPR_A(0), GPR_D(0)); |
| 278 |
– |
} |
| 279 |
– |
|
| 280 |
– |
void sheepshaver_cpu::execute_emul_op_idle_time_1() |
| 281 |
– |
{ |
| 282 |
– |
// Sleep if no events pending |
| 283 |
– |
if (ReadMacInt32(0x14c) == 0) |
| 284 |
– |
Delay_usec(16667); |
| 285 |
– |
GPR_A(0) = ReadMacInt32(0x2b6); |
| 286 |
– |
} |
| 287 |
– |
|
| 288 |
– |
void sheepshaver_cpu::execute_emul_op_idle_time_2() |
| 289 |
– |
{ |
| 290 |
– |
// Sleep if no events pending |
| 291 |
– |
if (ReadMacInt32(0x14c) == 0) |
| 292 |
– |
Delay_usec(16667); |
| 293 |
– |
GPR_D(0) = (uint32)-2; |
| 294 |
– |
} |
| 295 |
– |
|
| 296 |
– |
// Filter out EMUL_OP routines that only call native code |
| 297 |
– |
bool sheepshaver_cpu::filter_execute_emul_op(uint32 emul_op) |
| 298 |
– |
{ |
| 299 |
– |
switch (emul_op) { |
| 300 |
– |
case OP_MICROSECONDS: |
| 301 |
– |
execute_emul_op_microseconds(); |
| 302 |
– |
return true; |
| 303 |
– |
case OP_IDLE_TIME: |
| 304 |
– |
execute_emul_op_idle_time_1(); |
| 305 |
– |
return true; |
| 306 |
– |
case OP_IDLE_TIME_2: |
| 307 |
– |
execute_emul_op_idle_time_2(); |
| 308 |
– |
return true; |
| 309 |
– |
} |
| 310 |
– |
return false; |
| 311 |
– |
} |
| 312 |
– |
|
| 255 |
|
// Execute EMUL_OP routine |
| 256 |
|
void sheepshaver_cpu::execute_emul_op(uint32 emul_op) |
| 257 |
|
{ |
| 316 |
– |
#if ENABLE_NATIVE_EMUL_OP |
| 317 |
– |
// First, filter out EMUL_OPs that can be executed without a mode switch |
| 318 |
– |
if (filter_execute_emul_op(emul_op)) |
| 319 |
– |
return; |
| 320 |
– |
#endif |
| 321 |
– |
|
| 258 |
|
M68kRegisters r68; |
| 259 |
|
WriteMacInt32(XLM_68K_R25, gpr(25)); |
| 260 |
|
WriteMacInt32(XLM_RUN_MODE, MODE_EMUL_OP); |
| 307 |
|
} |
| 308 |
|
|
| 309 |
|
// Compile one instruction |
| 310 |
+ |
#if PPC_ENABLE_JIT |
| 311 |
|
int sheepshaver_cpu::compile1(codegen_context_t & cg_context) |
| 312 |
|
{ |
| 376 |
– |
#if PPC_ENABLE_JIT |
| 313 |
|
const instr_info_t *ii = cg_context.instr_info; |
| 314 |
|
if (ii->mnemo != PPC_I(SHEEP)) |
| 315 |
|
return COMPILE_FAILURE; |
| 380 |
|
status = COMPILE_CODE_OK; |
| 381 |
|
break; |
| 382 |
|
#endif |
| 447 |
– |
case NATIVE_DISABLE_INTERRUPT: |
| 448 |
– |
dg.gen_invoke(DisableInterrupt); |
| 449 |
– |
status = COMPILE_CODE_OK; |
| 450 |
– |
break; |
| 451 |
– |
case NATIVE_ENABLE_INTERRUPT: |
| 452 |
– |
dg.gen_invoke(EnableInterrupt); |
| 453 |
– |
status = COMPILE_CODE_OK; |
| 454 |
– |
break; |
| 383 |
|
case NATIVE_BITBLT: |
| 384 |
|
dg.gen_load_T0_GPR(3); |
| 385 |
|
dg.gen_invoke_T0((void (*)(uint32))NQD_bitblt); |
| 436 |
|
|
| 437 |
|
default: { // EMUL_OP |
| 438 |
|
uint32 emul_op = EMUL_OP_field::extract(opcode) - 3; |
| 511 |
– |
#if ENABLE_NATIVE_EMUL_OP |
| 512 |
– |
typedef void (*emul_op_func_t)(dyngen_cpu_base); |
| 513 |
– |
emul_op_func_t emul_op_func = 0; |
| 514 |
– |
switch (emul_op) { |
| 515 |
– |
case OP_MICROSECONDS: |
| 516 |
– |
emul_op_func = (emul_op_func_t)nv_mem_fun(&sheepshaver_cpu::execute_emul_op_microseconds).ptr(); |
| 517 |
– |
break; |
| 518 |
– |
case OP_IDLE_TIME: |
| 519 |
– |
emul_op_func = (emul_op_func_t)nv_mem_fun(&sheepshaver_cpu::execute_emul_op_idle_time_1).ptr(); |
| 520 |
– |
break; |
| 521 |
– |
case OP_IDLE_TIME_2: |
| 522 |
– |
emul_op_func = (emul_op_func_t)nv_mem_fun(&sheepshaver_cpu::execute_emul_op_idle_time_2).ptr(); |
| 523 |
– |
break; |
| 524 |
– |
} |
| 525 |
– |
if (emul_op_func) { |
| 526 |
– |
dg.gen_invoke_CPU(emul_op_func); |
| 527 |
– |
cg_context.done_compile = false; |
| 528 |
– |
status = COMPILE_CODE_OK; |
| 529 |
– |
break; |
| 530 |
– |
} |
| 531 |
– |
#endif |
| 439 |
|
#if PPC_REENTRANT_JIT |
| 440 |
|
// Try to execute EmulOp trampoline |
| 441 |
|
dg.gen_set_PC_im(cg_context.pc + 4); |
| 455 |
|
} |
| 456 |
|
} |
| 457 |
|
return status; |
| 551 |
– |
#endif |
| 552 |
– |
return COMPILE_FAILURE; |
| 553 |
– |
} |
| 554 |
– |
|
| 555 |
– |
// CPU context to preserve on interrupt |
| 556 |
– |
sheepshaver_cpu::interrupt_context::interrupt_context(sheepshaver_cpu *_cpu, const char *_where) |
| 557 |
– |
{ |
| 558 |
– |
#if SAFE_INTERRUPT_PPC >= 2 |
| 559 |
– |
cpu = _cpu; |
| 560 |
– |
where = _where; |
| 561 |
– |
|
| 562 |
– |
// Save interrupt context |
| 563 |
– |
memcpy(&gpr[0], &cpu->gpr(0), sizeof(gpr)); |
| 564 |
– |
pc = cpu->pc(); |
| 565 |
– |
lr = cpu->lr(); |
| 566 |
– |
ctr = cpu->ctr(); |
| 567 |
– |
cr = cpu->get_cr(); |
| 568 |
– |
xer = cpu->get_xer(); |
| 569 |
– |
#endif |
| 458 |
|
} |
| 571 |
– |
|
| 572 |
– |
sheepshaver_cpu::interrupt_context::~interrupt_context() |
| 573 |
– |
{ |
| 574 |
– |
#if SAFE_INTERRUPT_PPC >= 2 |
| 575 |
– |
// Check whether CPU context was preserved by interrupt |
| 576 |
– |
if (memcmp(&gpr[0], &cpu->gpr(0), sizeof(gpr)) != 0) { |
| 577 |
– |
printf("FATAL: %s: interrupt clobbers registers\n", where); |
| 578 |
– |
for (int i = 0; i < 32; i++) |
| 579 |
– |
if (gpr[i] != cpu->gpr(i)) |
| 580 |
– |
printf(" r%d: %08x -> %08x\n", i, gpr[i], cpu->gpr(i)); |
| 581 |
– |
} |
| 582 |
– |
if (pc != cpu->pc()) |
| 583 |
– |
printf("FATAL: %s: interrupt clobbers PC\n", where); |
| 584 |
– |
if (lr != cpu->lr()) |
| 585 |
– |
printf("FATAL: %s: interrupt clobbers LR\n", where); |
| 586 |
– |
if (ctr != cpu->ctr()) |
| 587 |
– |
printf("FATAL: %s: interrupt clobbers CTR\n", where); |
| 588 |
– |
if (cr != cpu->get_cr()) |
| 589 |
– |
printf("FATAL: %s: interrupt clobbers CR\n", where); |
| 590 |
– |
if (xer != cpu->get_xer()) |
| 591 |
– |
printf("FATAL: %s: interrupt clobbers XER\n", where); |
| 459 |
|
#endif |
| 593 |
– |
} |
| 460 |
|
|
| 461 |
|
// Handle MacOS interrupt |
| 462 |
|
void sheepshaver_cpu::interrupt(uint32 entry) |
| 463 |
|
{ |
| 464 |
|
#if EMUL_TIME_STATS |
| 465 |
< |
interrupt_count++; |
| 465 |
> |
ppc_interrupt_count++; |
| 466 |
|
const clock_t interrupt_start = clock(); |
| 467 |
|
#endif |
| 468 |
|
|
| 603 |
– |
#if SAFE_INTERRUPT_PPC |
| 604 |
– |
static int depth = 0; |
| 605 |
– |
if (depth != 0) |
| 606 |
– |
printf("FATAL: sheepshaver_cpu::interrupt() called more than once: %d\n", depth); |
| 607 |
– |
depth++; |
| 608 |
– |
#endif |
| 609 |
– |
|
| 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 |
| 663 |
– |
|
| 664 |
– |
#if SAFE_INTERRUPT_PPC |
| 665 |
– |
depth--; |
| 666 |
– |
#endif |
| 522 |
|
} |
| 523 |
|
|
| 524 |
|
// Execute 68k routine |
| 737 |
|
* Initialize CPU emulation |
| 738 |
|
*/ |
| 739 |
|
|
| 740 |
< |
static sigsegv_return_t sigsegv_handler(sigsegv_address_t fault_address, sigsegv_address_t fault_instruction) |
| 740 |
> |
sigsegv_return_t sigsegv_handler(sigsegv_address_t fault_address, sigsegv_address_t fault_instruction) |
| 741 |
|
{ |
| 742 |
|
#if ENABLE_VOSF |
| 743 |
|
// Handle screen fault |
| 749 |
|
const uintptr addr = (uintptr)fault_address; |
| 750 |
|
#if HAVE_SIGSEGV_SKIP_INSTRUCTION |
| 751 |
|
// Ignore writes to ROM |
| 752 |
< |
if ((addr - ROM_BASE) < ROM_SIZE) |
| 752 |
> |
if ((addr - (uintptr)ROMBaseHost) < ROM_SIZE) |
| 753 |
|
return SIGSEGV_RETURN_SKIP_INSTRUCTION; |
| 754 |
|
|
| 755 |
|
// Get program counter of target CPU |
| 809 |
|
|
| 810 |
|
void init_emul_ppc(void) |
| 811 |
|
{ |
| 812 |
+ |
// Get pointer to KernelData in host address space |
| 813 |
+ |
kernel_data = (KernelData *)Mac2HostAddr(KERNEL_DATA_BASE); |
| 814 |
+ |
|
| 815 |
|
// Initialize main CPU emulator |
| 816 |
|
ppc_cpu = new sheepshaver_cpu(); |
| 817 |
|
ppc_cpu->set_register(powerpc_registers::GPR(3), any_register((uint32)ROM_BASE + 0x30d000)); |
| 818 |
|
ppc_cpu->set_register(powerpc_registers::GPR(4), any_register(KernelDataAddr + 0x1000)); |
| 819 |
|
WriteMacInt32(XLM_RUN_MODE, MODE_68K); |
| 820 |
|
|
| 963 |
– |
// Install the handler for SIGSEGV |
| 964 |
– |
sigsegv_install_handler(sigsegv_handler); |
| 965 |
– |
|
| 821 |
|
#if ENABLE_MON |
| 822 |
|
// Install "regs" command in cxmon |
| 823 |
|
mon_add_command("regs", dump_registers, "regs Dump PowerPC registers\n"); |
| 843 |
|
printf("Total emulation time : %.1f sec\n", double(emul_time) / double(CLOCKS_PER_SEC)); |
| 844 |
|
printf("Total interrupt count: %d (%2.1f Hz)\n", interrupt_count, |
| 845 |
|
(double(interrupt_count) * CLOCKS_PER_SEC) / double(emul_time)); |
| 846 |
+ |
printf("Total ppc interrupt count: %d (%2.1f %%)\n", ppc_interrupt_count, |
| 847 |
+ |
(double(ppc_interrupt_count) * 100.0) / double(interrupt_count)); |
| 848 |
|
|
| 849 |
|
#define PRINT_STATS(LABEL, VAR_PREFIX) do { \ |
| 850 |
|
printf("Total " LABEL " count : %d\n", VAR_PREFIX##_count); \ |
| 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() |
| 925 |
+ |
SDL_PumpEvents(); |
| 926 |
+ |
#endif |
| 927 |
+ |
|
| 928 |
|
// Do nothing if interrupts are disabled |
| 929 |
< |
if (*(int32 *)XLM_IRQ_NEST > 0) |
| 929 |
> |
if (int32(ReadMacInt32(XLM_IRQ_NEST)) > 0) |
| 930 |
|
return; |
| 931 |
|
|
| 932 |
< |
// Do nothing if there is no interrupt pending |
| 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; |
| 939 |
< |
|
| 940 |
< |
// Disable MacOS stack sniffer |
| 941 |
< |
WriteMacInt32(0x110, 0); |
| 939 |
> |
#if EMUL_TIME_STATS |
| 940 |
> |
interrupt_count++; |
| 941 |
> |
#endif |
| 942 |
|
|
| 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) { |
| 1093 |
< |
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) { |
| 976 |
< |
interrupt_context ctx(this, "68k mode"); |
| 976 |
> |
#if EMUL_TIME_STATS |
| 977 |
> |
const clock_t interrupt_start = clock(); |
| 978 |
> |
#endif |
| 979 |
|
#if 1 |
| 980 |
|
// Execute full 68k interrupt routine |
| 981 |
|
M68kRegisters r; |
| 982 |
|
uint32 old_r25 = ReadMacInt32(XLM_68K_R25); // Save interrupt level |
| 983 |
|
WriteMacInt32(XLM_68K_R25, 0x21); // Execute with interrupt level 1 |
| 984 |
< |
static const uint8 proc[] = { |
| 984 |
> |
static const uint8 proc_template[] = { |
| 985 |
|
0x3f, 0x3c, 0x00, 0x00, // move.w #$0000,-(sp) (fake format word) |
| 986 |
|
0x48, 0x7a, 0x00, 0x0a, // pea @1(pc) (return address) |
| 987 |
|
0x40, 0xe7, // move sr,-(sp) (saved SR) |
| 989 |
|
0x4e, 0xd0, // jmp (a0) |
| 990 |
|
M68K_RTS >> 8, M68K_RTS & 0xff // @1 |
| 991 |
|
}; |
| 992 |
< |
Execute68k((uint32)proc, &r); |
| 992 |
> |
BUILD_SHEEPSHAVER_PROCEDURE(proc); |
| 993 |
> |
Execute68k(proc, &r); |
| 994 |
|
WriteMacInt32(XLM_68K_R25, old_r25); // Restore interrupt level |
| 995 |
|
#else |
| 996 |
|
// Only update cursor |
| 1002 |
|
} |
| 1003 |
|
} |
| 1004 |
|
#endif |
| 1005 |
+ |
#if EMUL_TIME_STATS |
| 1006 |
+ |
interrupt_time += (clock() - interrupt_start); |
| 1007 |
+ |
#endif |
| 1008 |
|
} |
| 1009 |
|
break; |
| 1010 |
|
#endif |
| 1039 |
|
VideoVBL(); |
| 1040 |
|
break; |
| 1041 |
|
case NATIVE_VIDEO_DO_DRIVER_IO: |
| 1042 |
< |
gpr(3) = (int32)(int16)VideoDoDriverIO((void *)gpr(3), (void *)gpr(4), |
| 1176 |
< |
(void *)gpr(5), gpr(6), gpr(7)); |
| 1042 |
> |
gpr(3) = (int32)(int16)VideoDoDriverIO(gpr(3), gpr(4), gpr(5), gpr(6), gpr(7)); |
| 1043 |
|
break; |
| 1178 |
– |
#ifdef WORDS_BIGENDIAN |
| 1044 |
|
case NATIVE_ETHER_IRQ: |
| 1045 |
|
EtherIRQ(); |
| 1046 |
|
break; |
| 1062 |
|
case NATIVE_ETHER_RSRV: |
| 1063 |
|
gpr(3) = ether_rsrv((queue_t *)gpr(3)); |
| 1064 |
|
break; |
| 1200 |
– |
#else |
| 1201 |
– |
case NATIVE_ETHER_INIT: |
| 1202 |
– |
// FIXME: needs more complicated thunks |
| 1203 |
– |
gpr(3) = false; |
| 1204 |
– |
break; |
| 1205 |
– |
#endif |
| 1065 |
|
case NATIVE_SYNC_HOOK: |
| 1066 |
|
gpr(3) = NQD_sync_hook(gpr(3)); |
| 1067 |
|
break; |
| 1116 |
|
get_resource_callbacks[selector - NATIVE_GET_RESOURCE](); |
| 1117 |
|
break; |
| 1118 |
|
} |
| 1260 |
– |
case NATIVE_DISABLE_INTERRUPT: |
| 1261 |
– |
DisableInterrupt(); |
| 1262 |
– |
break; |
| 1263 |
– |
case NATIVE_ENABLE_INTERRUPT: |
| 1264 |
– |
EnableInterrupt(); |
| 1265 |
– |
break; |
| 1119 |
|
case NATIVE_MAKE_EXECUTABLE: |
| 1120 |
< |
MakeExecutable(0, (void *)gpr(4), gpr(5)); |
| 1120 |
> |
MakeExecutable(0, gpr(4), gpr(5)); |
| 1121 |
|
break; |
| 1122 |
|
case NATIVE_CHECK_LOAD_INVOC: |
| 1123 |
|
check_load_invoc(gpr(3), gpr(4), gpr(5)); |
