| 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" |
| 93 |
|
// PowerPC EmulOp to exit from emulation looop |
| 94 |
|
const uint32 POWERPC_EXEC_RETURN = POWERPC_EMUL_OP | 1; |
| 95 |
|
|
| 89 |
– |
// Enable interrupt routine safety checks? |
| 90 |
– |
#define SAFE_INTERRUPT_PPC 1 |
| 91 |
– |
|
| 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 |
|
|
| 104 |
– |
// Enable native EMUL_OPs to be run without a mode switch |
| 105 |
– |
#define ENABLE_NATIVE_EMUL_OP 1 |
| 106 |
– |
|
| 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 |
|
|
| 141 |
– |
// Filter out EMUL_OP routines that only call native code |
| 142 |
– |
bool filter_execute_emul_op(uint32 emul_op); |
| 143 |
– |
|
| 144 |
– |
// "Native" EMUL_OP routines |
| 145 |
– |
void execute_emul_op_microseconds(); |
| 146 |
– |
void execute_emul_op_idle_time_1(); |
| 147 |
– |
void execute_emul_op_idle_time_2(); |
| 148 |
– |
|
| 149 |
– |
// CPU context to preserve on interrupt |
| 150 |
– |
class interrupt_context { |
| 151 |
– |
uint32 gpr[32]; |
| 152 |
– |
uint32 pc; |
| 153 |
– |
uint32 lr; |
| 154 |
– |
uint32 ctr; |
| 155 |
– |
uint32 cr; |
| 156 |
– |
uint32 xer; |
| 157 |
– |
sheepshaver_cpu *cpu; |
| 158 |
– |
const char *where; |
| 159 |
– |
public: |
| 160 |
– |
interrupt_context(sheepshaver_cpu *_cpu, const char *_where); |
| 161 |
– |
~interrupt_context(); |
| 162 |
– |
}; |
| 163 |
– |
|
| 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); |
| 198 |
– |
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 |
|
|
| 204 |
– |
// Memory allocator returning areas aligned on 16-byte boundaries |
| 205 |
– |
void *operator new(size_t size) |
| 206 |
– |
{ |
| 207 |
– |
void *p; |
| 208 |
– |
|
| 209 |
– |
#if defined(HAVE_POSIX_MEMALIGN) |
| 210 |
– |
if (posix_memalign(&p, 16, size) != 0) |
| 211 |
– |
throw std::bad_alloc(); |
| 212 |
– |
#elif defined(HAVE_MEMALIGN) |
| 213 |
– |
p = memalign(16, size); |
| 214 |
– |
#elif defined(HAVE_VALLOC) |
| 215 |
– |
p = valloc(size); // page-aligned! |
| 216 |
– |
#else |
| 217 |
– |
/* XXX: handle padding ourselves */ |
| 218 |
– |
p = malloc(size); |
| 219 |
– |
#endif |
| 220 |
– |
|
| 221 |
– |
return p; |
| 222 |
– |
} |
| 223 |
– |
|
| 224 |
– |
void operator delete(void *p) |
| 225 |
– |
{ |
| 226 |
– |
#if defined(HAVE_MEMALIGN) || defined(HAVE_VALLOC) |
| 227 |
– |
#if defined(__GLIBC__) |
| 228 |
– |
// this is known to work only with GNU libc |
| 229 |
– |
free(p); |
| 230 |
– |
#endif |
| 231 |
– |
#else |
| 232 |
– |
free(p); |
| 233 |
– |
#endif |
| 234 |
– |
} |
| 235 |
– |
|
| 182 |
|
sheepshaver_cpu::sheepshaver_cpu() |
| 183 |
|
: powerpc_cpu(enable_jit_p()) |
| 184 |
|
{ |
| 216 |
|
typedef bit_field< 20, 25 > NATIVE_OP_field; |
| 217 |
|
typedef bit_field< 26, 31 > EMUL_OP_field; |
| 218 |
|
|
| 273 |
– |
// "Native" EMUL_OP routines |
| 274 |
– |
#define GPR_A(REG) gpr(16 + (REG)) |
| 275 |
– |
#define GPR_D(REG) gpr( 8 + (REG)) |
| 276 |
– |
|
| 277 |
– |
void sheepshaver_cpu::execute_emul_op_microseconds() |
| 278 |
– |
{ |
| 279 |
– |
Microseconds(GPR_A(0), GPR_D(0)); |
| 280 |
– |
} |
| 281 |
– |
|
| 282 |
– |
void sheepshaver_cpu::execute_emul_op_idle_time_1() |
| 283 |
– |
{ |
| 284 |
– |
// Sleep if no events pending |
| 285 |
– |
if (ReadMacInt32(0x14c) == 0) |
| 286 |
– |
Delay_usec(16667); |
| 287 |
– |
GPR_A(0) = ReadMacInt32(0x2b6); |
| 288 |
– |
} |
| 289 |
– |
|
| 290 |
– |
void sheepshaver_cpu::execute_emul_op_idle_time_2() |
| 291 |
– |
{ |
| 292 |
– |
// Sleep if no events pending |
| 293 |
– |
if (ReadMacInt32(0x14c) == 0) |
| 294 |
– |
Delay_usec(16667); |
| 295 |
– |
GPR_D(0) = (uint32)-2; |
| 296 |
– |
} |
| 297 |
– |
|
| 298 |
– |
// Filter out EMUL_OP routines that only call native code |
| 299 |
– |
bool sheepshaver_cpu::filter_execute_emul_op(uint32 emul_op) |
| 300 |
– |
{ |
| 301 |
– |
switch (emul_op) { |
| 302 |
– |
case OP_MICROSECONDS: |
| 303 |
– |
execute_emul_op_microseconds(); |
| 304 |
– |
return true; |
| 305 |
– |
case OP_IDLE_TIME: |
| 306 |
– |
execute_emul_op_idle_time_1(); |
| 307 |
– |
return true; |
| 308 |
– |
case OP_IDLE_TIME_2: |
| 309 |
– |
execute_emul_op_idle_time_2(); |
| 310 |
– |
return true; |
| 311 |
– |
} |
| 312 |
– |
return false; |
| 313 |
– |
} |
| 314 |
– |
|
| 219 |
|
// Execute EMUL_OP routine |
| 220 |
|
void sheepshaver_cpu::execute_emul_op(uint32 emul_op) |
| 221 |
|
{ |
| 318 |
– |
#if ENABLE_NATIVE_EMUL_OP |
| 319 |
– |
// First, filter out EMUL_OPs that can be executed without a mode switch |
| 320 |
– |
if (filter_execute_emul_op(emul_op)) |
| 321 |
– |
return; |
| 322 |
– |
#endif |
| 323 |
– |
|
| 222 |
|
M68kRegisters r68; |
| 223 |
|
WriteMacInt32(XLM_68K_R25, gpr(25)); |
| 224 |
|
WriteMacInt32(XLM_RUN_MODE, MODE_EMUL_OP); |
| 227 |
|
for (int i = 0; i < 7; i++) |
| 228 |
|
r68.a[i] = gpr(16 + i); |
| 229 |
|
r68.a[7] = gpr(1); |
| 230 |
< |
uint32 saved_cr = get_cr() & CR_field<2>::mask(); |
| 230 |
> |
uint32 saved_cr = get_cr() & 0xff9fffff; // mask_operand::compute(11, 8) |
| 231 |
|
uint32 saved_xer = get_xer(); |
| 232 |
|
EmulOp(&r68, gpr(24), emul_op); |
| 233 |
|
set_cr(saved_cr); |
| 271 |
|
} |
| 272 |
|
|
| 273 |
|
// Compile one instruction |
| 274 |
+ |
#if PPC_ENABLE_JIT |
| 275 |
|
int sheepshaver_cpu::compile1(codegen_context_t & cg_context) |
| 276 |
|
{ |
| 378 |
– |
#if PPC_ENABLE_JIT |
| 277 |
|
const instr_info_t *ii = cg_context.instr_info; |
| 278 |
|
if (ii->mnemo != PPC_I(SHEEP)) |
| 279 |
|
return COMPILE_FAILURE; |
| 344 |
|
status = COMPILE_CODE_OK; |
| 345 |
|
break; |
| 346 |
|
#endif |
| 449 |
– |
case NATIVE_DISABLE_INTERRUPT: |
| 450 |
– |
dg.gen_invoke(DisableInterrupt); |
| 451 |
– |
status = COMPILE_CODE_OK; |
| 452 |
– |
break; |
| 453 |
– |
case NATIVE_ENABLE_INTERRUPT: |
| 454 |
– |
dg.gen_invoke(EnableInterrupt); |
| 455 |
– |
status = COMPILE_CODE_OK; |
| 456 |
– |
break; |
| 347 |
|
case NATIVE_BITBLT: |
| 348 |
|
dg.gen_load_T0_GPR(3); |
| 349 |
|
dg.gen_invoke_T0((void (*)(uint32))NQD_bitblt); |
| 400 |
|
|
| 401 |
|
default: { // EMUL_OP |
| 402 |
|
uint32 emul_op = EMUL_OP_field::extract(opcode) - 3; |
| 513 |
– |
#if ENABLE_NATIVE_EMUL_OP |
| 514 |
– |
typedef void (*emul_op_func_t)(dyngen_cpu_base); |
| 515 |
– |
emul_op_func_t emul_op_func = 0; |
| 516 |
– |
switch (emul_op) { |
| 517 |
– |
case OP_MICROSECONDS: |
| 518 |
– |
emul_op_func = (emul_op_func_t)nv_mem_fun(&sheepshaver_cpu::execute_emul_op_microseconds).ptr(); |
| 519 |
– |
break; |
| 520 |
– |
case OP_IDLE_TIME: |
| 521 |
– |
emul_op_func = (emul_op_func_t)nv_mem_fun(&sheepshaver_cpu::execute_emul_op_idle_time_1).ptr(); |
| 522 |
– |
break; |
| 523 |
– |
case OP_IDLE_TIME_2: |
| 524 |
– |
emul_op_func = (emul_op_func_t)nv_mem_fun(&sheepshaver_cpu::execute_emul_op_idle_time_2).ptr(); |
| 525 |
– |
break; |
| 526 |
– |
} |
| 527 |
– |
if (emul_op_func) { |
| 528 |
– |
dg.gen_invoke_CPU(emul_op_func); |
| 529 |
– |
cg_context.done_compile = false; |
| 530 |
– |
status = COMPILE_CODE_OK; |
| 531 |
– |
break; |
| 532 |
– |
} |
| 533 |
– |
#endif |
| 403 |
|
#if PPC_REENTRANT_JIT |
| 404 |
|
// Try to execute EmulOp trampoline |
| 405 |
|
dg.gen_set_PC_im(cg_context.pc + 4); |
| 419 |
|
} |
| 420 |
|
} |
| 421 |
|
return status; |
| 553 |
– |
#endif |
| 554 |
– |
return COMPILE_FAILURE; |
| 422 |
|
} |
| 556 |
– |
|
| 557 |
– |
// CPU context to preserve on interrupt |
| 558 |
– |
sheepshaver_cpu::interrupt_context::interrupt_context(sheepshaver_cpu *_cpu, const char *_where) |
| 559 |
– |
{ |
| 560 |
– |
#if SAFE_INTERRUPT_PPC >= 2 |
| 561 |
– |
cpu = _cpu; |
| 562 |
– |
where = _where; |
| 563 |
– |
|
| 564 |
– |
// Save interrupt context |
| 565 |
– |
memcpy(&gpr[0], &cpu->gpr(0), sizeof(gpr)); |
| 566 |
– |
pc = cpu->pc(); |
| 567 |
– |
lr = cpu->lr(); |
| 568 |
– |
ctr = cpu->ctr(); |
| 569 |
– |
cr = cpu->get_cr(); |
| 570 |
– |
xer = cpu->get_xer(); |
| 423 |
|
#endif |
| 572 |
– |
} |
| 573 |
– |
|
| 574 |
– |
sheepshaver_cpu::interrupt_context::~interrupt_context() |
| 575 |
– |
{ |
| 576 |
– |
#if SAFE_INTERRUPT_PPC >= 2 |
| 577 |
– |
// Check whether CPU context was preserved by interrupt |
| 578 |
– |
if (memcmp(&gpr[0], &cpu->gpr(0), sizeof(gpr)) != 0) { |
| 579 |
– |
printf("FATAL: %s: interrupt clobbers registers\n", where); |
| 580 |
– |
for (int i = 0; i < 32; i++) |
| 581 |
– |
if (gpr[i] != cpu->gpr(i)) |
| 582 |
– |
printf(" r%d: %08x -> %08x\n", i, gpr[i], cpu->gpr(i)); |
| 583 |
– |
} |
| 584 |
– |
if (pc != cpu->pc()) |
| 585 |
– |
printf("FATAL: %s: interrupt clobbers PC\n", where); |
| 586 |
– |
if (lr != cpu->lr()) |
| 587 |
– |
printf("FATAL: %s: interrupt clobbers LR\n", where); |
| 588 |
– |
if (ctr != cpu->ctr()) |
| 589 |
– |
printf("FATAL: %s: interrupt clobbers CTR\n", where); |
| 590 |
– |
if (cr != cpu->get_cr()) |
| 591 |
– |
printf("FATAL: %s: interrupt clobbers CR\n", where); |
| 592 |
– |
if (xer != cpu->get_xer()) |
| 593 |
– |
printf("FATAL: %s: interrupt clobbers XER\n", where); |
| 594 |
– |
#endif |
| 595 |
– |
} |
| 424 |
|
|
| 425 |
|
// Handle MacOS interrupt |
| 426 |
|
void sheepshaver_cpu::interrupt(uint32 entry) |
| 430 |
|
const clock_t interrupt_start = clock(); |
| 431 |
|
#endif |
| 432 |
|
|
| 605 |
– |
#if SAFE_INTERRUPT_PPC |
| 606 |
– |
static int depth = 0; |
| 607 |
– |
if (depth != 0) |
| 608 |
– |
printf("FATAL: sheepshaver_cpu::interrupt() called more than once: %d\n", depth); |
| 609 |
– |
depth++; |
| 610 |
– |
#endif |
| 611 |
– |
|
| 433 |
|
// Save program counters and branch registers |
| 434 |
|
uint32 saved_pc = pc(); |
| 435 |
|
uint32 saved_lr = lr(); |
| 483 |
|
#if EMUL_TIME_STATS |
| 484 |
|
interrupt_time += (clock() - interrupt_start); |
| 485 |
|
#endif |
| 665 |
– |
|
| 666 |
– |
#if SAFE_INTERRUPT_PPC |
| 667 |
– |
depth--; |
| 668 |
– |
#endif |
| 486 |
|
} |
| 487 |
|
|
| 488 |
|
// Execute 68k routine |
| 701 |
|
* Initialize CPU emulation |
| 702 |
|
*/ |
| 703 |
|
|
| 704 |
< |
static sigsegv_return_t sigsegv_handler(sigsegv_address_t fault_address, sigsegv_address_t fault_instruction) |
| 704 |
> |
sigsegv_return_t sigsegv_handler(sigsegv_address_t fault_address, sigsegv_address_t fault_instruction) |
| 705 |
|
{ |
| 706 |
|
#if ENABLE_VOSF |
| 707 |
|
// Handle screen fault |
| 713 |
|
const uintptr addr = (uintptr)fault_address; |
| 714 |
|
#if HAVE_SIGSEGV_SKIP_INSTRUCTION |
| 715 |
|
// Ignore writes to ROM |
| 716 |
< |
if ((addr - ROM_BASE) < ROM_SIZE) |
| 716 |
> |
if ((addr - (uintptr)ROMBaseHost) < ROM_SIZE) |
| 717 |
|
return SIGSEGV_RETURN_SKIP_INSTRUCTION; |
| 718 |
|
|
| 719 |
|
// Get program counter of target CPU |
| 760 |
|
#error "FIXME: You don't have the capability to skip instruction within signal handlers" |
| 761 |
|
#endif |
| 762 |
|
|
| 763 |
< |
printf("SIGSEGV\n"); |
| 764 |
< |
printf(" pc %p\n", fault_instruction); |
| 765 |
< |
printf(" ea %p\n", fault_address); |
| 763 |
> |
fprintf(stderr, "SIGSEGV\n"); |
| 764 |
> |
fprintf(stderr, " pc %p\n", fault_instruction); |
| 765 |
> |
fprintf(stderr, " ea %p\n", fault_address); |
| 766 |
|
dump_registers(); |
| 767 |
|
ppc_cpu->dump_log(); |
| 768 |
|
enter_mon(); |
| 773 |
|
|
| 774 |
|
void init_emul_ppc(void) |
| 775 |
|
{ |
| 776 |
+ |
// Get pointer to KernelData in host address space |
| 777 |
+ |
kernel_data = (KernelData *)Mac2HostAddr(KERNEL_DATA_BASE); |
| 778 |
+ |
|
| 779 |
|
// Initialize main CPU emulator |
| 780 |
|
ppc_cpu = new sheepshaver_cpu(); |
| 781 |
|
ppc_cpu->set_register(powerpc_registers::GPR(3), any_register((uint32)ROM_BASE + 0x30d000)); |
| 782 |
|
ppc_cpu->set_register(powerpc_registers::GPR(4), any_register(KernelDataAddr + 0x1000)); |
| 783 |
|
WriteMacInt32(XLM_RUN_MODE, MODE_68K); |
| 784 |
|
|
| 965 |
– |
// Install the handler for SIGSEGV |
| 966 |
– |
sigsegv_install_handler(sigsegv_handler); |
| 967 |
– |
|
| 785 |
|
#if ENABLE_MON |
| 786 |
|
// Install "regs" command in cxmon |
| 787 |
|
mon_add_command("regs", dump_registers, "regs Dump PowerPC registers\n"); |
| 826 |
|
#endif |
| 827 |
|
|
| 828 |
|
delete ppc_cpu; |
| 829 |
+ |
ppc_cpu = NULL; |
| 830 |
|
} |
| 831 |
|
|
| 832 |
|
#if PPC_ENABLE_JIT && PPC_REENTRANT_JIT |
| 874 |
|
|
| 875 |
|
void TriggerInterrupt(void) |
| 876 |
|
{ |
| 877 |
+ |
idle_resume(); |
| 878 |
|
#if 0 |
| 879 |
|
WriteMacInt32(0x16a, ReadMacInt32(0x16a) + 1); |
| 880 |
|
#else |
| 884 |
|
#endif |
| 885 |
|
} |
| 886 |
|
|
| 887 |
< |
void sheepshaver_cpu::handle_interrupt(void) |
| 887 |
> |
void HandleInterrupt(powerpc_registers *r) |
| 888 |
|
{ |
| 889 |
+ |
#ifdef USE_SDL_VIDEO |
| 890 |
+ |
// We must fill in the events queue in the same thread that did call SDL_SetVideoMode() |
| 891 |
+ |
SDL_PumpEvents(); |
| 892 |
+ |
#endif |
| 893 |
+ |
|
| 894 |
|
// Do nothing if interrupts are disabled |
| 895 |
< |
if (*(int32 *)XLM_IRQ_NEST > 0) |
| 895 |
> |
if (int32(ReadMacInt32(XLM_IRQ_NEST)) > 0) |
| 896 |
|
return; |
| 897 |
|
|
| 898 |
< |
// Current interrupt nest level |
| 1075 |
< |
static int interrupt_depth = 0; |
| 1076 |
< |
++interrupt_depth; |
| 898 |
> |
// Update interrupt count |
| 899 |
|
#if EMUL_TIME_STATS |
| 900 |
|
interrupt_count++; |
| 901 |
|
#endif |
| 902 |
|
|
| 1081 |
– |
// Disable MacOS stack sniffer |
| 1082 |
– |
WriteMacInt32(0x110, 0); |
| 1083 |
– |
|
| 903 |
|
// Interrupt action depends on current run mode |
| 904 |
|
switch (ReadMacInt32(XLM_RUN_MODE)) { |
| 905 |
|
case MODE_68K: |
| 906 |
|
// 68k emulator active, trigger 68k interrupt level 1 |
| 907 |
|
WriteMacInt16(tswap32(kernel_data->v[0x67c >> 2]), 1); |
| 908 |
< |
set_cr(get_cr() | tswap32(kernel_data->v[0x674 >> 2])); |
| 908 |
> |
r->cr.set(r->cr.get() | tswap32(kernel_data->v[0x674 >> 2])); |
| 909 |
|
break; |
| 910 |
|
|
| 911 |
|
#if INTERRUPTS_IN_NATIVE_MODE |
| 912 |
|
case MODE_NATIVE: |
| 913 |
|
// 68k emulator inactive, in nanokernel? |
| 914 |
< |
if (gpr(1) != KernelDataAddr && interrupt_depth == 1) { |
| 1096 |
< |
interrupt_context ctx(this, "PowerPC mode"); |
| 914 |
> |
if (r->gpr[1] != KernelDataAddr) { |
| 915 |
|
|
| 916 |
|
// Prepare for 68k interrupt level 1 |
| 917 |
|
WriteMacInt16(tswap32(kernel_data->v[0x67c >> 2]), 1); |
| 933 |
|
case MODE_EMUL_OP: |
| 934 |
|
// 68k emulator active, within EMUL_OP routine, execute 68k interrupt routine directly when interrupt level is 0 |
| 935 |
|
if ((ReadMacInt32(XLM_68K_R25) & 7) == 0) { |
| 1118 |
– |
interrupt_context ctx(this, "68k mode"); |
| 936 |
|
#if EMUL_TIME_STATS |
| 937 |
|
const clock_t interrupt_start = clock(); |
| 938 |
|
#endif |
| 941 |
|
M68kRegisters r; |
| 942 |
|
uint32 old_r25 = ReadMacInt32(XLM_68K_R25); // Save interrupt level |
| 943 |
|
WriteMacInt32(XLM_68K_R25, 0x21); // Execute with interrupt level 1 |
| 944 |
< |
static const uint8 proc[] = { |
| 944 |
> |
static const uint8 proc_template[] = { |
| 945 |
|
0x3f, 0x3c, 0x00, 0x00, // move.w #$0000,-(sp) (fake format word) |
| 946 |
|
0x48, 0x7a, 0x00, 0x0a, // pea @1(pc) (return address) |
| 947 |
|
0x40, 0xe7, // move sr,-(sp) (saved SR) |
| 949 |
|
0x4e, 0xd0, // jmp (a0) |
| 950 |
|
M68K_RTS >> 8, M68K_RTS & 0xff // @1 |
| 951 |
|
}; |
| 952 |
< |
Execute68k((uint32)proc, &r); |
| 952 |
> |
BUILD_SHEEPSHAVER_PROCEDURE(proc); |
| 953 |
> |
Execute68k(proc, &r); |
| 954 |
|
WriteMacInt32(XLM_68K_R25, old_r25); // Restore interrupt level |
| 955 |
|
#else |
| 956 |
|
// Only update cursor |
| 969 |
|
break; |
| 970 |
|
#endif |
| 971 |
|
} |
| 1154 |
– |
|
| 1155 |
– |
// We are done with this interrupt |
| 1156 |
– |
--interrupt_depth; |
| 972 |
|
} |
| 973 |
|
|
| 974 |
|
static void get_resource(void); |
| 996 |
|
VideoVBL(); |
| 997 |
|
break; |
| 998 |
|
case NATIVE_VIDEO_DO_DRIVER_IO: |
| 999 |
< |
gpr(3) = (int32)(int16)VideoDoDriverIO((void *)gpr(3), (void *)gpr(4), |
| 1000 |
< |
(void *)gpr(5), gpr(6), gpr(7)); |
| 999 |
> |
gpr(3) = (int32)(int16)VideoDoDriverIO(gpr(3), gpr(4), gpr(5), gpr(6), gpr(7)); |
| 1000 |
> |
break; |
| 1001 |
> |
case NATIVE_ETHER_AO_GET_HWADDR: |
| 1002 |
> |
AO_get_ethernet_address(gpr(3)); |
| 1003 |
> |
break; |
| 1004 |
> |
case NATIVE_ETHER_AO_ADD_MULTI: |
| 1005 |
> |
AO_enable_multicast(gpr(3)); |
| 1006 |
> |
break; |
| 1007 |
> |
case NATIVE_ETHER_AO_DEL_MULTI: |
| 1008 |
> |
AO_disable_multicast(gpr(3)); |
| 1009 |
> |
break; |
| 1010 |
> |
case NATIVE_ETHER_AO_SEND_PACKET: |
| 1011 |
> |
AO_transmit_packet(gpr(3)); |
| 1012 |
|
break; |
| 1187 |
– |
#ifdef WORDS_BIGENDIAN |
| 1013 |
|
case NATIVE_ETHER_IRQ: |
| 1014 |
|
EtherIRQ(); |
| 1015 |
|
break; |
| 1031 |
|
case NATIVE_ETHER_RSRV: |
| 1032 |
|
gpr(3) = ether_rsrv((queue_t *)gpr(3)); |
| 1033 |
|
break; |
| 1209 |
– |
#else |
| 1210 |
– |
case NATIVE_ETHER_INIT: |
| 1211 |
– |
// FIXME: needs more complicated thunks |
| 1212 |
– |
gpr(3) = false; |
| 1213 |
– |
break; |
| 1214 |
– |
#endif |
| 1034 |
|
case NATIVE_SYNC_HOOK: |
| 1035 |
|
gpr(3) = NQD_sync_hook(gpr(3)); |
| 1036 |
|
break; |
| 1085 |
|
get_resource_callbacks[selector - NATIVE_GET_RESOURCE](); |
| 1086 |
|
break; |
| 1087 |
|
} |
| 1269 |
– |
case NATIVE_DISABLE_INTERRUPT: |
| 1270 |
– |
DisableInterrupt(); |
| 1271 |
– |
break; |
| 1272 |
– |
case NATIVE_ENABLE_INTERRUPT: |
| 1273 |
– |
EnableInterrupt(); |
| 1274 |
– |
break; |
| 1088 |
|
case NATIVE_MAKE_EXECUTABLE: |
| 1089 |
< |
MakeExecutable(0, (void *)gpr(4), gpr(5)); |
| 1089 |
> |
MakeExecutable(0, gpr(4), gpr(5)); |
| 1090 |
|
break; |
| 1091 |
|
case NATIVE_CHECK_LOAD_INVOC: |
| 1092 |
|
check_load_invoc(gpr(3), gpr(4), gpr(5)); |
