1 |
|
/* |
2 |
|
* main_unix.cpp - Emulation core, Unix implementation |
3 |
|
* |
4 |
< |
* SheepShaver (C) 1997-2002 Christian Bauer and Marc Hellwig |
4 |
> |
* SheepShaver (C) 1997-2004 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 |
65 |
|
* ExecutePPC (or any function that might cause a mode switch). The signal |
66 |
|
* stack is restored before exiting the SIGUSR2 handler. |
67 |
|
* |
68 |
+ |
* There is apparently another problem when processing signals. In |
69 |
+ |
* fullscreen mode, we get quick updates of the mouse position. This |
70 |
+ |
* causes an increased number of calls to TriggerInterrupt(). And, |
71 |
+ |
* since IRQ_NEST is not fully handled atomically, nested calls to |
72 |
+ |
* ppc_interrupt() may cause stack corruption to eventually crash the |
73 |
+ |
* emulator. |
74 |
+ |
* |
75 |
+ |
* FIXME: |
76 |
+ |
* The current solution is to allocate another signal stack when |
77 |
+ |
* processing ppc_interrupt(). However, it may be better to detect |
78 |
+ |
* the INTFLAG_ADB case and handle it specifically with some extra mutex? |
79 |
+ |
* |
80 |
|
* TODO: |
81 |
|
* check if SIGSEGV handler works for all registers (including FP!) |
82 |
|
*/ |
144 |
|
#endif |
145 |
|
|
146 |
|
|
147 |
+ |
// Enable emulation of unaligned lmw/stmw? |
148 |
+ |
#define EMULATE_UNALIGNED_LOADSTORE_MULTIPLE 1 |
149 |
+ |
|
150 |
|
// Enable Execute68k() safety checks? |
151 |
|
#define SAFE_EXEC_68K 0 |
152 |
|
|
156 |
|
// Interrupts in native mode? |
157 |
|
#define INTERRUPTS_IN_NATIVE_MODE 1 |
158 |
|
|
159 |
+ |
// Number of alternate stacks for signal handlers? |
160 |
+ |
#define SIG_STACK_COUNT 4 |
161 |
+ |
|
162 |
|
|
163 |
|
// Constants |
164 |
|
const char ROM_FILE_NAME[] = "ROM"; |
169 |
|
|
170 |
|
|
171 |
|
#if !EMULATED_PPC |
154 |
– |
// Structure in which registers are saved in a signal handler; |
155 |
– |
// sigcontext->regs points to it |
156 |
– |
// (see arch/ppc/kernel/signal.c) |
157 |
– |
typedef struct { |
158 |
– |
uint32 u[4]; |
159 |
– |
} __attribute((aligned(16))) vector128; |
160 |
– |
#include <linux/elf.h> |
161 |
– |
|
172 |
|
struct sigregs { |
173 |
< |
elf_gregset_t gp_regs; // Identical to pt_regs |
174 |
< |
double fp_regs[ELF_NFPREG]; // f0..f31 and fpsrc |
175 |
< |
//more (uninteresting) stuff following here |
173 |
> |
uint32 nip; |
174 |
> |
uint32 link; |
175 |
> |
uint32 ctr; |
176 |
> |
uint32 msr; |
177 |
> |
uint32 xer; |
178 |
> |
uint32 ccr; |
179 |
> |
uint32 gpr[32]; |
180 |
> |
}; |
181 |
> |
|
182 |
> |
#if defined(__linux__) |
183 |
> |
#include <sys/ucontext.h> |
184 |
> |
#define MACHINE_REGISTERS(scp) ((machine_regs *)(((ucontext_t *)scp)->uc_mcontext.regs)) |
185 |
> |
|
186 |
> |
struct machine_regs : public pt_regs |
187 |
> |
{ |
188 |
> |
u_long & cr() { return pt_regs::ccr; } |
189 |
> |
uint32 cr() const { return pt_regs::ccr; } |
190 |
> |
uint32 lr() const { return pt_regs::link; } |
191 |
> |
uint32 ctr() const { return pt_regs::ctr; } |
192 |
> |
uint32 xer() const { return pt_regs::xer; } |
193 |
> |
uint32 msr() const { return pt_regs::msr; } |
194 |
> |
uint32 dar() const { return pt_regs::dar; } |
195 |
> |
u_long & pc() { return pt_regs::nip; } |
196 |
> |
uint32 pc() const { return pt_regs::nip; } |
197 |
> |
u_long & gpr(int i) { return pt_regs::gpr[i]; } |
198 |
> |
uint32 gpr(int i) const { return pt_regs::gpr[i]; } |
199 |
> |
}; |
200 |
> |
#endif |
201 |
> |
|
202 |
> |
#if defined(__APPLE__) && defined(__MACH__) |
203 |
> |
#include <sys/signal.h> |
204 |
> |
extern "C" int sigaltstack(const struct sigaltstack *ss, struct sigaltstack *oss); |
205 |
> |
|
206 |
> |
#include <sys/ucontext.h> |
207 |
> |
#define MACHINE_REGISTERS(scp) ((machine_regs *)(((ucontext_t *)scp)->uc_mcontext)) |
208 |
> |
|
209 |
> |
struct machine_regs : public mcontext |
210 |
> |
{ |
211 |
> |
uint32 & cr() { return ss.cr; } |
212 |
> |
uint32 cr() const { return ss.cr; } |
213 |
> |
uint32 lr() const { return ss.lr; } |
214 |
> |
uint32 ctr() const { return ss.ctr; } |
215 |
> |
uint32 xer() const { return ss.xer; } |
216 |
> |
uint32 msr() const { return ss.srr1; } |
217 |
> |
uint32 dar() const { return es.dar; } |
218 |
> |
uint32 & pc() { return ss.srr0; } |
219 |
> |
uint32 pc() const { return ss.srr0; } |
220 |
> |
uint32 & gpr(int i) { return (&ss.r0)[i]; } |
221 |
> |
uint32 gpr(int i) const { return (&ss.r0)[i]; } |
222 |
|
}; |
223 |
|
#endif |
224 |
|
|
225 |
+ |
static void build_sigregs(sigregs *srp, machine_regs *mrp) |
226 |
+ |
{ |
227 |
+ |
srp->nip = mrp->pc(); |
228 |
+ |
srp->link = mrp->lr(); |
229 |
+ |
srp->ctr = mrp->ctr(); |
230 |
+ |
srp->msr = mrp->msr(); |
231 |
+ |
srp->xer = mrp->xer(); |
232 |
+ |
srp->ccr = mrp->cr(); |
233 |
+ |
for (int i = 0; i < 32; i++) |
234 |
+ |
srp->gpr[i] = mrp->gpr(i); |
235 |
+ |
} |
236 |
+ |
|
237 |
+ |
static struct sigaltstack sig_stacks[SIG_STACK_COUNT]; // Stacks for signal handlers |
238 |
+ |
static int sig_stack_id = 0; // Stack slot currently used |
239 |
+ |
|
240 |
+ |
static inline void sig_stack_acquire(void) |
241 |
+ |
{ |
242 |
+ |
if (++sig_stack_id == SIG_STACK_COUNT) { |
243 |
+ |
printf("FATAL: signal stack overflow\n"); |
244 |
+ |
return; |
245 |
+ |
} |
246 |
+ |
sigaltstack(&sig_stacks[sig_stack_id], NULL); |
247 |
+ |
} |
248 |
+ |
|
249 |
+ |
static inline void sig_stack_release(void) |
250 |
+ |
{ |
251 |
+ |
if (--sig_stack_id < 0) { |
252 |
+ |
printf("FATAL: signal stack underflow\n"); |
253 |
+ |
return; |
254 |
+ |
} |
255 |
+ |
sigaltstack(&sig_stacks[sig_stack_id], NULL); |
256 |
+ |
} |
257 |
+ |
#endif |
258 |
+ |
|
259 |
|
|
260 |
|
// Global variables (exported) |
261 |
|
#if !EMULATED_PPC |
273 |
|
// Global variables |
274 |
|
char *x_display_name = NULL; // X11 display name |
275 |
|
Display *x_display = NULL; // X11 display handle |
276 |
+ |
#ifdef X11_LOCK_TYPE |
277 |
+ |
X11_LOCK_TYPE x_display_lock = X11_LOCK_INIT; // X11 display lock |
278 |
+ |
#endif |
279 |
|
|
280 |
|
static int zero_fd = 0; // FD of /dev/zero |
281 |
|
static bool lm_area_mapped = false; // Flag: Low Memory area mmap()ped |
297 |
|
static int64 num_segv = 0; // Number of handled SEGV signals |
298 |
|
|
299 |
|
static struct sigaction sigusr2_action; // Interrupt signal (of emulator thread) |
300 |
< |
#if !EMULATED_PPC |
300 |
> |
#if EMULATED_PPC |
301 |
> |
static uintptr sig_stack = 0; // Stack for PowerPC interrupt routine |
302 |
> |
#else |
303 |
|
static struct sigaction sigsegv_action; // Data access exception signal (of emulator thread) |
304 |
|
static struct sigaction sigill_action; // Illegal instruction signal (of emulator thread) |
210 |
– |
static void *sig_stack = NULL; // Stack for signal handlers |
211 |
– |
static void *extra_stack = NULL; // Stack for SIGSEGV inside interrupt handler |
305 |
|
static bool emul_thread_fatal = false; // Flag: MacOS thread crashed, tick thread shall dump debug output |
306 |
|
static sigregs sigsegv_regs; // Register dump when crashed |
307 |
+ |
static const char *crash_reason = NULL; // Reason of the crash (SIGSEGV, SIGBUS, SIGILL) |
308 |
|
#endif |
309 |
|
|
310 |
+ |
uint32 SheepMem::page_size; // Size of a native page |
311 |
|
uintptr SheepMem::zero_page = 0; // Address of ro page filled in with zeros |
312 |
|
uintptr SheepMem::base = 0x60000000; // Address of SheepShaver data |
313 |
|
uintptr SheepMem::top = 0; // Top of SheepShaver data (stack like storage) |
319 |
|
static void *nvram_func(void *arg); |
320 |
|
static void *tick_func(void *arg); |
321 |
|
#if EMULATED_PPC |
227 |
– |
static void sigusr2_handler(int sig); |
322 |
|
extern void emul_ppc(uint32 start); |
323 |
|
extern void init_emul_ppc(void); |
324 |
|
extern void exit_emul_ppc(void); |
325 |
|
#else |
326 |
< |
static void sigusr2_handler(int sig, sigcontext_struct *sc); |
327 |
< |
static void sigsegv_handler(int sig, sigcontext_struct *sc); |
328 |
< |
static void sigill_handler(int sig, sigcontext_struct *sc); |
326 |
> |
static void sigusr2_handler(int sig, siginfo_t *sip, void *scp); |
327 |
> |
static void sigsegv_handler(int sig, siginfo_t *sip, void *scp); |
328 |
> |
static void sigill_handler(int sig, siginfo_t *sip, void *scp); |
329 |
|
#endif |
330 |
|
|
331 |
|
|
347 |
|
|
348 |
|
#if EMULATED_PPC |
349 |
|
/* |
350 |
+ |
* Return signal stack base |
351 |
+ |
*/ |
352 |
+ |
|
353 |
+ |
uintptr SignalStackBase(void) |
354 |
+ |
{ |
355 |
+ |
return sig_stack + SIG_STACK_SIZE; |
356 |
+ |
} |
357 |
+ |
|
358 |
+ |
|
359 |
+ |
/* |
360 |
|
* Atomic operations |
361 |
|
*/ |
362 |
|
|
480 |
|
PVR = 0x00040000; // Default: 604 |
481 |
|
CPUClockSpeed = 100000000; // Default: 100MHz |
482 |
|
BusClockSpeed = 100000000; // Default: 100MHz |
483 |
< |
#if !EMULATED_PPC |
483 |
> |
#if EMULATED_PPC |
484 |
> |
PVR = 0x000c0000; // Default: 7400 (with AltiVec) |
485 |
> |
#else |
486 |
|
proc_file = fopen("/proc/cpuinfo", "r"); |
487 |
|
if (proc_file) { |
488 |
|
char line[256]; |
496 |
|
// Parse line |
497 |
|
int i; |
498 |
|
char value[256]; |
499 |
< |
if (sscanf(line, "cpu : %s", value) == 1) { |
499 |
> |
if (sscanf(line, "cpu : %[0-9A-Za-a]", value) == 1) { |
500 |
|
if (strcmp(value, "601") == 0) |
501 |
|
PVR = 0x00010000; |
502 |
|
else if (strcmp(value, "603") == 0) |
517 |
|
PVR = 0x00320000; |
518 |
|
else if (strcmp(value, "860") == 0) |
519 |
|
PVR = 0x00500000; |
520 |
+ |
else if (strcmp(value, "7400") == 0) |
521 |
+ |
PVR = 0x000c0000; |
522 |
+ |
else if (strcmp(value, "7410") == 0) |
523 |
+ |
PVR = 0x800c0000; |
524 |
|
else |
525 |
|
printf("WARNING: Unknown CPU type '%s', assuming 604\n", value); |
526 |
|
} |
532 |
|
sprintf(str, GetString(STR_PROC_CPUINFO_WARN), strerror(errno)); |
533 |
|
WarningAlert(str); |
534 |
|
} |
535 |
+ |
|
536 |
+ |
// Get actual bus frequency |
537 |
+ |
proc_file = fopen("/proc/device-tree/clock-frequency", "r"); |
538 |
+ |
if (proc_file) { |
539 |
+ |
union { uint8 b[4]; uint32 l; } value; |
540 |
+ |
if (fread(value.b, sizeof(value), 1, proc_file) == 1) |
541 |
+ |
BusClockSpeed = value.l; |
542 |
+ |
fclose(proc_file); |
543 |
+ |
} |
544 |
|
#endif |
545 |
|
D(bug("PVR: %08x (assumed)\n", PVR)); |
546 |
|
|
565 |
|
goto quit; |
566 |
|
} |
567 |
|
|
568 |
+ |
#ifndef PAGEZERO_HACK |
569 |
|
// Create Low Memory area (0x0000..0x3000) |
570 |
|
if (vm_acquire_fixed((char *)0, 0x3000) < 0) { |
571 |
|
sprintf(str, GetString(STR_LOW_MEM_MMAP_ERR), strerror(errno)); |
573 |
|
goto quit; |
574 |
|
} |
575 |
|
lm_area_mapped = true; |
576 |
+ |
#endif |
577 |
|
|
578 |
|
// Create areas for Kernel Data |
579 |
|
kernel_area = shmget(IPC_PRIVATE, KERNEL_AREA_SIZE, 0600); |
610 |
|
ErrorAlert(str); |
611 |
|
goto quit; |
612 |
|
} |
613 |
< |
#if !EMULATED_PPC || defined(__powerpc__) |
613 |
> |
#if !EMULATED_PPC |
614 |
|
if (vm_protect((char *)ROM_BASE, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) { |
615 |
|
sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno)); |
616 |
|
ErrorAlert(str); |
680 |
|
// Load NVRAM |
681 |
|
XPRAMInit(); |
682 |
|
|
683 |
+ |
// Load XPRAM default values if signature not found |
684 |
+ |
if (XPRAM[0x130c] != 0x4e || XPRAM[0x130d] != 0x75 |
685 |
+ |
|| XPRAM[0x130e] != 0x4d || XPRAM[0x130f] != 0x63) { |
686 |
+ |
D(bug("Loading XPRAM default values\n")); |
687 |
+ |
memset(XPRAM + 0x1300, 0, 0x100); |
688 |
+ |
XPRAM[0x130c] = 0x4e; // "NuMc" signature |
689 |
+ |
XPRAM[0x130d] = 0x75; |
690 |
+ |
XPRAM[0x130e] = 0x4d; |
691 |
+ |
XPRAM[0x130f] = 0x63; |
692 |
+ |
XPRAM[0x1301] = 0x80; // InternalWaitFlags = DynWait (don't wait for SCSI devices upon bootup) |
693 |
+ |
XPRAM[0x1310] = 0xa8; // Standard PRAM values |
694 |
+ |
XPRAM[0x1311] = 0x00; |
695 |
+ |
XPRAM[0x1312] = 0x00; |
696 |
+ |
XPRAM[0x1313] = 0x22; |
697 |
+ |
XPRAM[0x1314] = 0xcc; |
698 |
+ |
XPRAM[0x1315] = 0x0a; |
699 |
+ |
XPRAM[0x1316] = 0xcc; |
700 |
+ |
XPRAM[0x1317] = 0x0a; |
701 |
+ |
XPRAM[0x131c] = 0x00; |
702 |
+ |
XPRAM[0x131d] = 0x02; |
703 |
+ |
XPRAM[0x131e] = 0x63; |
704 |
+ |
XPRAM[0x131f] = 0x00; |
705 |
+ |
XPRAM[0x1308] = 0x13; |
706 |
+ |
XPRAM[0x1309] = 0x88; |
707 |
+ |
XPRAM[0x130a] = 0x00; |
708 |
+ |
XPRAM[0x130b] = 0xcc; |
709 |
+ |
XPRAM[0x1376] = 0x00; // OSDefault = MacOS |
710 |
+ |
XPRAM[0x1377] = 0x01; |
711 |
+ |
} |
712 |
+ |
|
713 |
|
// Set boot volume |
714 |
|
i16 = PrefsFindInt32("bootdrive"); |
715 |
|
XPRAM[0x1378] = i16 >> 8; |
740 |
|
// Init external file system |
741 |
|
ExtFSInit(); |
742 |
|
|
743 |
+ |
// Init ADB |
744 |
+ |
ADBInit(); |
745 |
+ |
|
746 |
|
// Init audio |
747 |
|
AudioInit(); |
748 |
|
|
800 |
|
kernel_data->v[0xc50 >> 2] = htonl(RAMBase); |
801 |
|
kernel_data->v[0xc54 >> 2] = htonl(RAMSize); |
802 |
|
kernel_data->v[0xf60 >> 2] = htonl(PVR); |
803 |
< |
kernel_data->v[0xf64 >> 2] = htonl(CPUClockSpeed); |
804 |
< |
kernel_data->v[0xf68 >> 2] = htonl(BusClockSpeed); |
805 |
< |
kernel_data->v[0xf6c >> 2] = htonl(CPUClockSpeed); |
803 |
> |
kernel_data->v[0xf64 >> 2] = htonl(CPUClockSpeed); // clock-frequency |
804 |
> |
kernel_data->v[0xf68 >> 2] = htonl(BusClockSpeed); // bus-frequency |
805 |
> |
kernel_data->v[0xf6c >> 2] = htonl(BusClockSpeed / 4); // timebase-frequency |
806 |
|
} else { |
807 |
|
kernel_data->v[0xc80 >> 2] = htonl(RAMSize); |
808 |
|
kernel_data->v[0xc84 >> 2] = htonl(RAMSize); |
814 |
|
kernel_data->v[0xcb0 >> 2] = htonl(RAMBase); |
815 |
|
kernel_data->v[0xcb4 >> 2] = htonl(RAMSize); |
816 |
|
kernel_data->v[0xf80 >> 2] = htonl(PVR); |
817 |
< |
kernel_data->v[0xf84 >> 2] = htonl(CPUClockSpeed); |
818 |
< |
kernel_data->v[0xf88 >> 2] = htonl(BusClockSpeed); |
819 |
< |
kernel_data->v[0xf8c >> 2] = htonl(CPUClockSpeed); |
817 |
> |
kernel_data->v[0xf84 >> 2] = htonl(CPUClockSpeed); // clock-frequency |
818 |
> |
kernel_data->v[0xf88 >> 2] = htonl(BusClockSpeed); // bus-frequency |
819 |
> |
kernel_data->v[0xf8c >> 2] = htonl(BusClockSpeed / 4); // timebase-frequency |
820 |
|
} |
821 |
|
|
822 |
|
// Initialize extra low memory |
851 |
|
|
852 |
|
#if !EMULATED_PPC |
853 |
|
// Create and install stacks for signal handlers |
854 |
< |
sig_stack = malloc(SIG_STACK_SIZE); |
855 |
< |
D(bug("Signal stack at %p\n", sig_stack)); |
856 |
< |
if (sig_stack == NULL) { |
857 |
< |
ErrorAlert(GetString(STR_NOT_ENOUGH_MEMORY_ERR)); |
858 |
< |
goto quit; |
859 |
< |
} |
860 |
< |
extra_stack = malloc(SIG_STACK_SIZE); |
861 |
< |
D(bug("Extra stack at %p\n", extra_stack)); |
862 |
< |
if (extra_stack == NULL) { |
863 |
< |
ErrorAlert(GetString(STR_NOT_ENOUGH_MEMORY_ERR)); |
710 |
< |
goto quit; |
854 |
> |
for (int i = 0; i < SIG_STACK_COUNT; i++) { |
855 |
> |
void *sig_stack = malloc(SIG_STACK_SIZE); |
856 |
> |
D(bug("Signal stack %d at %p\n", i, sig_stack)); |
857 |
> |
if (sig_stack == NULL) { |
858 |
> |
ErrorAlert(GetString(STR_NOT_ENOUGH_MEMORY_ERR)); |
859 |
> |
goto quit; |
860 |
> |
} |
861 |
> |
sig_stacks[i].ss_sp = sig_stack; |
862 |
> |
sig_stacks[i].ss_flags = 0; |
863 |
> |
sig_stacks[i].ss_size = SIG_STACK_SIZE; |
864 |
|
} |
865 |
< |
struct sigaltstack new_stack; |
866 |
< |
new_stack.ss_sp = sig_stack; |
714 |
< |
new_stack.ss_flags = 0; |
715 |
< |
new_stack.ss_size = SIG_STACK_SIZE; |
716 |
< |
if (sigaltstack(&new_stack, NULL) < 0) { |
865 |
> |
sig_stack_id = 0; |
866 |
> |
if (sigaltstack(&sig_stacks[0], NULL) < 0) { |
867 |
|
sprintf(str, GetString(STR_SIGALTSTACK_ERR), strerror(errno)); |
868 |
|
ErrorAlert(str); |
869 |
|
goto quit; |
871 |
|
#endif |
872 |
|
|
873 |
|
#if !EMULATED_PPC |
874 |
< |
// Install SIGSEGV handler |
874 |
> |
// Install SIGSEGV and SIGBUS handlers |
875 |
|
sigemptyset(&sigsegv_action.sa_mask); // Block interrupts during SEGV handling |
876 |
|
sigaddset(&sigsegv_action.sa_mask, SIGUSR2); |
877 |
< |
sigsegv_action.sa_handler = (__sighandler_t)sigsegv_handler; |
878 |
< |
sigsegv_action.sa_flags = SA_ONSTACK; |
877 |
> |
sigsegv_action.sa_sigaction = sigsegv_handler; |
878 |
> |
sigsegv_action.sa_flags = SA_ONSTACK | SA_SIGINFO; |
879 |
> |
#ifdef HAVE_SIGNAL_SA_RESTORER |
880 |
|
sigsegv_action.sa_restorer = NULL; |
881 |
+ |
#endif |
882 |
|
if (sigaction(SIGSEGV, &sigsegv_action, NULL) < 0) { |
883 |
|
sprintf(str, GetString(STR_SIGSEGV_INSTALL_ERR), strerror(errno)); |
884 |
|
ErrorAlert(str); |
885 |
|
goto quit; |
886 |
|
} |
887 |
+ |
if (sigaction(SIGBUS, &sigsegv_action, NULL) < 0) { |
888 |
+ |
sprintf(str, GetString(STR_SIGSEGV_INSTALL_ERR), strerror(errno)); |
889 |
+ |
ErrorAlert(str); |
890 |
+ |
goto quit; |
891 |
+ |
} |
892 |
|
|
893 |
|
// Install SIGILL handler |
894 |
|
sigemptyset(&sigill_action.sa_mask); // Block interrupts during ILL handling |
895 |
|
sigaddset(&sigill_action.sa_mask, SIGUSR2); |
896 |
< |
sigill_action.sa_handler = (__sighandler_t)sigill_handler; |
897 |
< |
sigill_action.sa_flags = SA_ONSTACK; |
896 |
> |
sigill_action.sa_sigaction = sigill_handler; |
897 |
> |
sigill_action.sa_flags = SA_ONSTACK | SA_SIGINFO; |
898 |
> |
#ifdef HAVE_SIGNAL_SA_RESTORER |
899 |
|
sigill_action.sa_restorer = NULL; |
900 |
+ |
#endif |
901 |
|
if (sigaction(SIGILL, &sigill_action, NULL) < 0) { |
902 |
|
sprintf(str, GetString(STR_SIGILL_INSTALL_ERR), strerror(errno)); |
903 |
|
ErrorAlert(str); |
905 |
|
} |
906 |
|
#endif |
907 |
|
|
908 |
+ |
#if !EMULATED_PPC |
909 |
|
// Install interrupt signal handler |
910 |
|
sigemptyset(&sigusr2_action.sa_mask); |
911 |
< |
sigusr2_action.sa_handler = (__sighandler_t)sigusr2_handler; |
912 |
< |
sigusr2_action.sa_flags = 0; |
913 |
< |
#if !EMULATED_PPC |
754 |
< |
sigusr2_action.sa_flags = SA_ONSTACK | SA_RESTART; |
755 |
< |
#endif |
911 |
> |
sigusr2_action.sa_sigaction = sigusr2_handler; |
912 |
> |
sigusr2_action.sa_flags = SA_ONSTACK | SA_RESTART | SA_SIGINFO; |
913 |
> |
#ifdef HAVE_SIGNAL_SA_RESTORER |
914 |
|
sigusr2_action.sa_restorer = NULL; |
915 |
+ |
#endif |
916 |
|
if (sigaction(SIGUSR2, &sigusr2_action, NULL) < 0) { |
917 |
|
sprintf(str, GetString(STR_SIGUSR2_INSTALL_ERR), strerror(errno)); |
918 |
|
ErrorAlert(str); |
919 |
|
goto quit; |
920 |
|
} |
921 |
+ |
#endif |
922 |
|
|
923 |
|
// Get my thread ID and execute MacOS thread function |
924 |
|
emul_thread = pthread_self(); |
955 |
|
} |
956 |
|
|
957 |
|
#if !EMULATED_PPC |
958 |
< |
// Uninstall SIGSEGV handler |
958 |
> |
// Uninstall SIGSEGV and SIGBUS handlers |
959 |
|
sigemptyset(&sigsegv_action.sa_mask); |
960 |
|
sigsegv_action.sa_handler = SIG_DFL; |
961 |
|
sigsegv_action.sa_flags = 0; |
962 |
|
sigaction(SIGSEGV, &sigsegv_action, NULL); |
963 |
+ |
sigaction(SIGBUS, &sigsegv_action, NULL); |
964 |
|
|
965 |
|
// Uninstall SIGILL handler |
966 |
|
sigemptyset(&sigill_action.sa_mask); |
967 |
|
sigill_action.sa_handler = SIG_DFL; |
968 |
|
sigill_action.sa_flags = 0; |
969 |
|
sigaction(SIGILL, &sigill_action, NULL); |
970 |
+ |
|
971 |
+ |
// Delete stacks for signal handlers |
972 |
+ |
for (int i = 0; i < SIG_STACK_COUNT; i++) { |
973 |
+ |
void *sig_stack = sig_stacks[i].ss_sp; |
974 |
+ |
if (sig_stack) |
975 |
+ |
free(sig_stack); |
976 |
+ |
} |
977 |
|
#endif |
978 |
|
|
979 |
|
// Save NVRAM |
994 |
|
// Exit audio |
995 |
|
AudioExit(); |
996 |
|
|
997 |
+ |
// Exit ADB |
998 |
+ |
ADBExit(); |
999 |
+ |
|
1000 |
|
// Exit video |
1001 |
|
VideoExit(); |
1002 |
|
|
1009 |
|
DiskExit(); |
1010 |
|
SonyExit(); |
1011 |
|
|
1012 |
+ |
// Delete thunks |
1013 |
+ |
ThunksExit(); |
1014 |
+ |
|
1015 |
|
// Delete SheepShaver globals |
1016 |
|
SheepMem::Exit(); |
1017 |
|
|
1249 |
|
if (emul_thread_fatal) { |
1250 |
|
|
1251 |
|
// Yes, dump registers |
1252 |
< |
pt_regs *r = (pt_regs *)&sigsegv_regs; |
1252 |
> |
sigregs *r = &sigsegv_regs; |
1253 |
|
char str[256]; |
1254 |
< |
sprintf(str, "SIGSEGV\n" |
1254 |
> |
if (crash_reason == NULL) |
1255 |
> |
crash_reason = "SIGSEGV"; |
1256 |
> |
sprintf(str, "%s\n" |
1257 |
|
" pc %08lx lr %08lx ctr %08lx msr %08lx\n" |
1258 |
|
" xer %08lx cr %08lx \n" |
1259 |
|
" r0 %08lx r1 %08lx r2 %08lx r3 %08lx\n" |
1264 |
|
" r20 %08lx r21 %08lx r22 %08lx r23 %08lx\n" |
1265 |
|
" r24 %08lx r25 %08lx r26 %08lx r27 %08lx\n" |
1266 |
|
" r28 %08lx r29 %08lx r30 %08lx r31 %08lx\n", |
1267 |
+ |
crash_reason, |
1268 |
|
r->nip, r->link, r->ctr, r->msr, |
1269 |
|
r->xer, r->ccr, |
1270 |
|
r->gpr[0], r->gpr[1], r->gpr[2], r->gpr[3], |
1420 |
|
* Trigger signal USR2 from another thread |
1421 |
|
*/ |
1422 |
|
|
1423 |
< |
#if !EMULATED_PPC || ASYNC_IRQ |
1423 |
> |
#if !EMULATED_PPC |
1424 |
|
void TriggerInterrupt(void) |
1425 |
|
{ |
1426 |
|
if (ready_for_signals) |
1470 |
|
* USR2 handler |
1471 |
|
*/ |
1472 |
|
|
1473 |
< |
#if EMULATED_PPC |
1474 |
< |
static void sigusr2_handler(int sig) |
1298 |
< |
{ |
1299 |
< |
#if ASYNC_IRQ |
1300 |
< |
extern void HandleInterrupt(void); |
1301 |
< |
HandleInterrupt(); |
1302 |
< |
#endif |
1303 |
< |
} |
1304 |
< |
#else |
1305 |
< |
static void sigusr2_handler(int sig, sigcontext_struct *sc) |
1473 |
> |
#if !EMULATED_PPC |
1474 |
> |
static void sigusr2_handler(int sig, siginfo_t *sip, void *scp) |
1475 |
|
{ |
1476 |
< |
pt_regs *r = sc->regs; |
1476 |
> |
machine_regs *r = MACHINE_REGISTERS(scp); |
1477 |
|
|
1478 |
|
// Do nothing if interrupts are disabled |
1479 |
|
if (*(int32 *)XLM_IRQ_NEST > 0) |
1487 |
|
case MODE_68K: |
1488 |
|
// 68k emulator active, trigger 68k interrupt level 1 |
1489 |
|
WriteMacInt16(ntohl(kernel_data->v[0x67c >> 2]), 1); |
1490 |
< |
r->ccr |= ntohl(kernel_data->v[0x674 >> 2]); |
1490 |
> |
r->cr() |= ntohl(kernel_data->v[0x674 >> 2]); |
1491 |
|
break; |
1492 |
|
|
1493 |
|
#if INTERRUPTS_IN_NATIVE_MODE |
1494 |
|
case MODE_NATIVE: |
1495 |
|
// 68k emulator inactive, in nanokernel? |
1496 |
< |
if (r->gpr[1] != KernelDataAddr) { |
1496 |
> |
if (r->gpr(1) != KernelDataAddr) { |
1497 |
> |
|
1498 |
> |
// Set extra stack for nested interrupts |
1499 |
> |
sig_stack_acquire(); |
1500 |
> |
|
1501 |
|
// Prepare for 68k interrupt level 1 |
1502 |
|
WriteMacInt16(ntohl(kernel_data->v[0x67c >> 2]), 1); |
1503 |
|
WriteMacInt32(ntohl(kernel_data->v[0x658 >> 2]) + 0xdc, ReadMacInt32(ntohl(kernel_data->v[0x658 >> 2]) + 0xdc) | ntohl(kernel_data->v[0x674 >> 2])); |
1504 |
|
|
1505 |
|
// Execute nanokernel interrupt routine (this will activate the 68k emulator) |
1506 |
< |
atomic_add((int32 *)XLM_IRQ_NEST, 1); |
1506 |
> |
DisableInterrupt(); |
1507 |
|
if (ROMType == ROMTYPE_NEWWORLD) |
1508 |
|
ppc_interrupt(ROM_BASE + 0x312b1c, KernelDataAddr); |
1509 |
|
else |
1510 |
|
ppc_interrupt(ROM_BASE + 0x312a3c, KernelDataAddr); |
1511 |
+ |
|
1512 |
+ |
// Reset normal signal stack |
1513 |
+ |
sig_stack_release(); |
1514 |
|
} |
1515 |
|
break; |
1516 |
|
#endif |
1521 |
|
if ((ReadMacInt32(XLM_68K_R25) & 7) == 0) { |
1522 |
|
|
1523 |
|
// Set extra stack for SIGSEGV handler |
1524 |
< |
struct sigaltstack new_stack; |
1349 |
< |
new_stack.ss_sp = extra_stack; |
1350 |
< |
new_stack.ss_flags = 0; |
1351 |
< |
new_stack.ss_size = SIG_STACK_SIZE; |
1352 |
< |
sigaltstack(&new_stack, NULL); |
1524 |
> |
sig_stack_acquire(); |
1525 |
|
#if 1 |
1526 |
|
// Execute full 68k interrupt routine |
1527 |
|
M68kRegisters r; |
1548 |
|
} |
1549 |
|
#endif |
1550 |
|
// Reset normal signal stack |
1551 |
< |
new_stack.ss_sp = sig_stack; |
1380 |
< |
new_stack.ss_flags = 0; |
1381 |
< |
new_stack.ss_size = SIG_STACK_SIZE; |
1382 |
< |
sigaltstack(&new_stack, NULL); |
1551 |
> |
sig_stack_release(); |
1552 |
|
} |
1553 |
|
break; |
1554 |
|
#endif |
1562 |
|
*/ |
1563 |
|
|
1564 |
|
#if !EMULATED_PPC |
1565 |
< |
static void sigsegv_handler(int sig, sigcontext_struct *sc) |
1565 |
> |
static void sigsegv_handler(int sig, siginfo_t *sip, void *scp) |
1566 |
|
{ |
1567 |
< |
pt_regs *r = sc->regs; |
1567 |
> |
machine_regs *r = MACHINE_REGISTERS(scp); |
1568 |
|
|
1569 |
|
// Get effective address |
1570 |
< |
uint32 addr = r->dar; |
1570 |
> |
uint32 addr = r->dar(); |
1571 |
|
|
1572 |
|
#if ENABLE_VOSF |
1573 |
|
// Handle screen fault. |
1574 |
|
extern bool Screen_fault_handler(sigsegv_address_t fault_address, sigsegv_address_t fault_instruction); |
1575 |
< |
if (Screen_fault_handler((sigsegv_address_t)addr, (sigsegv_address_t)r->nip)) |
1575 |
> |
if (Screen_fault_handler((sigsegv_address_t)addr, (sigsegv_address_t)r->pc())) |
1576 |
|
return; |
1577 |
|
#endif |
1578 |
|
|
1579 |
|
num_segv++; |
1580 |
|
|
1581 |
|
// Fault in Mac ROM or RAM? |
1582 |
< |
bool mac_fault = (r->nip >= ROM_BASE) && (r->nip < (ROM_BASE + ROM_AREA_SIZE)) || (r->nip >= RAMBase) && (r->nip < (RAMBase + RAMSize)); |
1582 |
> |
bool mac_fault = (r->pc() >= ROM_BASE) && (r->pc() < (ROM_BASE + ROM_AREA_SIZE)) || (r->pc() >= RAMBase) && (r->pc() < (RAMBase + RAMSize)); |
1583 |
|
if (mac_fault) { |
1584 |
|
|
1585 |
|
// "VM settings" during MacOS 8 installation |
1586 |
< |
if (r->nip == ROM_BASE + 0x488160 && r->gpr[20] == 0xf8000000) { |
1587 |
< |
r->nip += 4; |
1588 |
< |
r->gpr[8] = 0; |
1586 |
> |
if (r->pc() == ROM_BASE + 0x488160 && r->gpr(20) == 0xf8000000) { |
1587 |
> |
r->pc() += 4; |
1588 |
> |
r->gpr(8) = 0; |
1589 |
|
return; |
1590 |
|
|
1591 |
|
// MacOS 8.5 installation |
1592 |
< |
} else if (r->nip == ROM_BASE + 0x488140 && r->gpr[16] == 0xf8000000) { |
1593 |
< |
r->nip += 4; |
1594 |
< |
r->gpr[8] = 0; |
1592 |
> |
} else if (r->pc() == ROM_BASE + 0x488140 && r->gpr(16) == 0xf8000000) { |
1593 |
> |
r->pc() += 4; |
1594 |
> |
r->gpr(8) = 0; |
1595 |
|
return; |
1596 |
|
|
1597 |
|
// MacOS 8 serial drivers on startup |
1598 |
< |
} else if (r->nip == ROM_BASE + 0x48e080 && (r->gpr[8] == 0xf3012002 || r->gpr[8] == 0xf3012000)) { |
1599 |
< |
r->nip += 4; |
1600 |
< |
r->gpr[8] = 0; |
1598 |
> |
} else if (r->pc() == ROM_BASE + 0x48e080 && (r->gpr(8) == 0xf3012002 || r->gpr(8) == 0xf3012000)) { |
1599 |
> |
r->pc() += 4; |
1600 |
> |
r->gpr(8) = 0; |
1601 |
|
return; |
1602 |
|
|
1603 |
|
// MacOS 8.1 serial drivers on startup |
1604 |
< |
} else if (r->nip == ROM_BASE + 0x48c5e0 && (r->gpr[20] == 0xf3012002 || r->gpr[20] == 0xf3012000)) { |
1605 |
< |
r->nip += 4; |
1604 |
> |
} else if (r->pc() == ROM_BASE + 0x48c5e0 && (r->gpr(20) == 0xf3012002 || r->gpr(20) == 0xf3012000)) { |
1605 |
> |
r->pc() += 4; |
1606 |
|
return; |
1607 |
< |
} else if (r->nip == ROM_BASE + 0x4a10a0 && (r->gpr[20] == 0xf3012002 || r->gpr[20] == 0xf3012000)) { |
1608 |
< |
r->nip += 4; |
1607 |
> |
} else if (r->pc() == ROM_BASE + 0x4a10a0 && (r->gpr(20) == 0xf3012002 || r->gpr(20) == 0xf3012000)) { |
1608 |
> |
r->pc() += 4; |
1609 |
|
return; |
1610 |
|
} |
1611 |
|
|
1612 |
|
// Get opcode and divide into fields |
1613 |
< |
uint32 opcode = *((uint32 *)r->nip); |
1613 |
> |
uint32 opcode = *((uint32 *)r->pc()); |
1614 |
|
uint32 primop = opcode >> 26; |
1615 |
|
uint32 exop = (opcode >> 1) & 0x3ff; |
1616 |
|
uint32 ra = (opcode >> 16) & 0x1f; |
1699 |
|
transfer_type = TYPE_STORE; transfer_size = SIZE_HALFWORD; addr_mode = MODE_NORM; break; |
1700 |
|
case 45: // sthu |
1701 |
|
transfer_type = TYPE_STORE; transfer_size = SIZE_HALFWORD; addr_mode = MODE_U; break; |
1702 |
+ |
#if EMULATE_UNALIGNED_LOADSTORE_MULTIPLE |
1703 |
+ |
case 46: // lmw |
1704 |
+ |
if ((addr % 4) != 0) { |
1705 |
+ |
uint32 ea = addr; |
1706 |
+ |
D(bug("WARNING: unaligned lmw to EA=%08x from IP=%08x\n", ea, r->pc())); |
1707 |
+ |
for (int i = rd; i <= 31; i++) { |
1708 |
+ |
r->gpr(i) = ReadMacInt32(ea); |
1709 |
+ |
ea += 4; |
1710 |
+ |
} |
1711 |
+ |
r->pc() += 4; |
1712 |
+ |
goto rti; |
1713 |
+ |
} |
1714 |
+ |
break; |
1715 |
+ |
case 47: // stmw |
1716 |
+ |
if ((addr % 4) != 0) { |
1717 |
+ |
uint32 ea = addr; |
1718 |
+ |
D(bug("WARNING: unaligned stmw to EA=%08x from IP=%08x\n", ea, r->pc())); |
1719 |
+ |
for (int i = rd; i <= 31; i++) { |
1720 |
+ |
WriteMacInt32(ea, r->gpr(i)); |
1721 |
+ |
ea += 4; |
1722 |
+ |
} |
1723 |
+ |
r->pc() += 4; |
1724 |
+ |
goto rti; |
1725 |
+ |
} |
1726 |
+ |
break; |
1727 |
+ |
#endif |
1728 |
|
} |
1729 |
|
|
1730 |
< |
// Ignore ROM writes |
1731 |
< |
if (transfer_type == TYPE_STORE && addr >= ROM_BASE && addr < ROM_BASE + ROM_SIZE) { |
1732 |
< |
// D(bug("WARNING: %s write access to ROM at %08lx, pc %08lx\n", transfer_size == SIZE_BYTE ? "Byte" : transfer_size == SIZE_HALFWORD ? "Halfword" : "Word", addr, r->nip)); |
1730 |
> |
// Ignore ROM writes (including to the zero page, which is read-only) |
1731 |
> |
if (transfer_type == TYPE_STORE && |
1732 |
> |
((addr >= ROM_BASE && addr < ROM_BASE + ROM_SIZE) || |
1733 |
> |
(addr >= SheepMem::ZeroPage() && addr < SheepMem::ZeroPage() + SheepMem::PageSize()))) { |
1734 |
> |
// D(bug("WARNING: %s write access to ROM at %08lx, pc %08lx\n", transfer_size == SIZE_BYTE ? "Byte" : transfer_size == SIZE_HALFWORD ? "Halfword" : "Word", addr, r->pc())); |
1735 |
|
if (addr_mode == MODE_U || addr_mode == MODE_UX) |
1736 |
< |
r->gpr[ra] = addr; |
1737 |
< |
r->nip += 4; |
1736 |
> |
r->gpr(ra) = addr; |
1737 |
> |
r->pc() += 4; |
1738 |
|
goto rti; |
1739 |
|
} |
1740 |
|
|
1741 |
|
// Ignore illegal memory accesses? |
1742 |
|
if (PrefsFindBool("ignoresegv")) { |
1743 |
|
if (addr_mode == MODE_U || addr_mode == MODE_UX) |
1744 |
< |
r->gpr[ra] = addr; |
1744 |
> |
r->gpr(ra) = addr; |
1745 |
|
if (transfer_type == TYPE_LOAD) |
1746 |
< |
r->gpr[rd] = 0; |
1747 |
< |
r->nip += 4; |
1746 |
> |
r->gpr(rd) = 0; |
1747 |
> |
r->pc() += 4; |
1748 |
|
goto rti; |
1749 |
|
} |
1750 |
|
|
1752 |
|
if (!PrefsFindBool("nogui")) { |
1753 |
|
char str[256]; |
1754 |
|
if (transfer_type == TYPE_LOAD || transfer_type == TYPE_STORE) |
1755 |
< |
sprintf(str, GetString(STR_MEM_ACCESS_ERR), transfer_size == SIZE_BYTE ? "byte" : transfer_size == SIZE_HALFWORD ? "halfword" : "word", transfer_type == TYPE_LOAD ? GetString(STR_MEM_ACCESS_READ) : GetString(STR_MEM_ACCESS_WRITE), addr, r->nip, r->gpr[24], r->gpr[1]); |
1755 |
> |
sprintf(str, GetString(STR_MEM_ACCESS_ERR), transfer_size == SIZE_BYTE ? "byte" : transfer_size == SIZE_HALFWORD ? "halfword" : "word", transfer_type == TYPE_LOAD ? GetString(STR_MEM_ACCESS_READ) : GetString(STR_MEM_ACCESS_WRITE), addr, r->pc(), r->gpr(24), r->gpr(1)); |
1756 |
|
else |
1757 |
< |
sprintf(str, GetString(STR_UNKNOWN_SEGV_ERR), r->nip, r->gpr[24], r->gpr[1], opcode); |
1757 |
> |
sprintf(str, GetString(STR_UNKNOWN_SEGV_ERR), r->pc(), r->gpr(24), r->gpr(1), opcode); |
1758 |
|
ErrorAlert(str); |
1759 |
|
QuitEmulator(); |
1760 |
|
return; |
1762 |
|
} |
1763 |
|
|
1764 |
|
// For all other errors, jump into debugger (sort of...) |
1765 |
+ |
crash_reason = (sig == SIGBUS) ? "SIGBUS" : "SIGSEGV"; |
1766 |
|
if (!ready_for_signals) { |
1767 |
< |
printf("SIGSEGV\n"); |
1768 |
< |
printf(" sigcontext %p, pt_regs %p\n", sc, r); |
1767 |
> |
printf("%s\n"); |
1768 |
> |
printf(" sigcontext %p, machine_regs %p\n", scp, r); |
1769 |
|
printf( |
1770 |
|
" pc %08lx lr %08lx ctr %08lx msr %08lx\n" |
1771 |
|
" xer %08lx cr %08lx \n" |
1777 |
|
" r20 %08lx r21 %08lx r22 %08lx r23 %08lx\n" |
1778 |
|
" r24 %08lx r25 %08lx r26 %08lx r27 %08lx\n" |
1779 |
|
" r28 %08lx r29 %08lx r30 %08lx r31 %08lx\n", |
1780 |
< |
r->nip, r->link, r->ctr, r->msr, |
1781 |
< |
r->xer, r->ccr, |
1782 |
< |
r->gpr[0], r->gpr[1], r->gpr[2], r->gpr[3], |
1783 |
< |
r->gpr[4], r->gpr[5], r->gpr[6], r->gpr[7], |
1784 |
< |
r->gpr[8], r->gpr[9], r->gpr[10], r->gpr[11], |
1785 |
< |
r->gpr[12], r->gpr[13], r->gpr[14], r->gpr[15], |
1786 |
< |
r->gpr[16], r->gpr[17], r->gpr[18], r->gpr[19], |
1787 |
< |
r->gpr[20], r->gpr[21], r->gpr[22], r->gpr[23], |
1788 |
< |
r->gpr[24], r->gpr[25], r->gpr[26], r->gpr[27], |
1789 |
< |
r->gpr[28], r->gpr[29], r->gpr[30], r->gpr[31]); |
1780 |
> |
crash_reason, |
1781 |
> |
r->pc(), r->lr(), r->ctr(), r->msr(), |
1782 |
> |
r->xer(), r->cr(), |
1783 |
> |
r->gpr(0), r->gpr(1), r->gpr(2), r->gpr(3), |
1784 |
> |
r->gpr(4), r->gpr(5), r->gpr(6), r->gpr(7), |
1785 |
> |
r->gpr(8), r->gpr(9), r->gpr(10), r->gpr(11), |
1786 |
> |
r->gpr(12), r->gpr(13), r->gpr(14), r->gpr(15), |
1787 |
> |
r->gpr(16), r->gpr(17), r->gpr(18), r->gpr(19), |
1788 |
> |
r->gpr(20), r->gpr(21), r->gpr(22), r->gpr(23), |
1789 |
> |
r->gpr(24), r->gpr(25), r->gpr(26), r->gpr(27), |
1790 |
> |
r->gpr(28), r->gpr(29), r->gpr(30), r->gpr(31)); |
1791 |
|
exit(1); |
1792 |
|
QuitEmulator(); |
1793 |
|
return; |
1794 |
|
} else { |
1795 |
|
// We crashed. Save registers, tell tick thread and loop forever |
1796 |
< |
sigsegv_regs = *(sigregs *)r; |
1796 |
> |
build_sigregs(&sigsegv_regs, r); |
1797 |
|
emul_thread_fatal = true; |
1798 |
|
for (;;) ; |
1799 |
|
} |
1805 |
|
* SIGILL handler |
1806 |
|
*/ |
1807 |
|
|
1808 |
< |
static void sigill_handler(int sig, sigcontext_struct *sc) |
1808 |
> |
static void sigill_handler(int sig, siginfo_t *sip, void *scp) |
1809 |
|
{ |
1810 |
< |
pt_regs *r = sc->regs; |
1810 |
> |
machine_regs *r = MACHINE_REGISTERS(scp); |
1811 |
|
char str[256]; |
1812 |
|
|
1813 |
|
// Fault in Mac ROM or RAM? |
1814 |
< |
bool mac_fault = (r->nip >= ROM_BASE) && (r->nip < (ROM_BASE + ROM_AREA_SIZE)) || (r->nip >= RAMBase) && (r->nip < (RAMBase + RAMSize)); |
1814 |
> |
bool mac_fault = (r->pc() >= ROM_BASE) && (r->pc() < (ROM_BASE + ROM_AREA_SIZE)) || (r->pc() >= RAMBase) && (r->pc() < (RAMBase + RAMSize)); |
1815 |
|
if (mac_fault) { |
1816 |
|
|
1817 |
|
// Get opcode and divide into fields |
1818 |
< |
uint32 opcode = *((uint32 *)r->nip); |
1818 |
> |
uint32 opcode = *((uint32 *)r->pc()); |
1819 |
|
uint32 primop = opcode >> 26; |
1820 |
|
uint32 exop = (opcode >> 1) & 0x3ff; |
1821 |
|
uint32 ra = (opcode >> 16) & 0x1f; |
1826 |
|
switch (primop) { |
1827 |
|
case 9: // POWER instructions |
1828 |
|
case 22: |
1829 |
< |
power_inst: sprintf(str, GetString(STR_POWER_INSTRUCTION_ERR), r->nip, r->gpr[1], opcode); |
1829 |
> |
power_inst: sprintf(str, GetString(STR_POWER_INSTRUCTION_ERR), r->pc(), r->gpr(1), opcode); |
1830 |
|
ErrorAlert(str); |
1831 |
|
QuitEmulator(); |
1832 |
|
return; |
1834 |
|
case 31: |
1835 |
|
switch (exop) { |
1836 |
|
case 83: // mfmsr |
1837 |
< |
r->gpr[rd] = 0xf072; |
1838 |
< |
r->nip += 4; |
1837 |
> |
r->gpr(rd) = 0xf072; |
1838 |
> |
r->pc() += 4; |
1839 |
|
goto rti; |
1840 |
|
|
1841 |
|
case 210: // mtsr |
1842 |
|
case 242: // mtsrin |
1843 |
|
case 306: // tlbie |
1844 |
< |
r->nip += 4; |
1844 |
> |
r->pc() += 4; |
1845 |
|
goto rti; |
1846 |
|
|
1847 |
|
case 339: { // mfspr |
1857 |
|
case 957: // PMC3 |
1858 |
|
case 958: // PMC4 |
1859 |
|
case 959: // SDA |
1860 |
< |
r->nip += 4; |
1860 |
> |
r->pc() += 4; |
1861 |
|
goto rti; |
1862 |
|
case 25: // SDR1 |
1863 |
< |
r->gpr[rd] = 0xdead001f; |
1864 |
< |
r->nip += 4; |
1863 |
> |
r->gpr(rd) = 0xdead001f; |
1864 |
> |
r->pc() += 4; |
1865 |
|
goto rti; |
1866 |
|
case 287: // PVR |
1867 |
< |
r->gpr[rd] = PVR; |
1868 |
< |
r->nip += 4; |
1867 |
> |
r->gpr(rd) = PVR; |
1868 |
> |
r->pc() += 4; |
1869 |
|
goto rti; |
1870 |
|
} |
1871 |
|
break; |
1901 |
|
case 957: // PMC3 |
1902 |
|
case 958: // PMC4 |
1903 |
|
case 959: // SDA |
1904 |
< |
r->nip += 4; |
1904 |
> |
r->pc() += 4; |
1905 |
|
goto rti; |
1906 |
|
} |
1907 |
|
break; |
1920 |
|
|
1921 |
|
// In GUI mode, show error alert |
1922 |
|
if (!PrefsFindBool("nogui")) { |
1923 |
< |
sprintf(str, GetString(STR_UNKNOWN_SEGV_ERR), r->nip, r->gpr[24], r->gpr[1], opcode); |
1923 |
> |
sprintf(str, GetString(STR_UNKNOWN_SEGV_ERR), r->pc(), r->gpr(24), r->gpr(1), opcode); |
1924 |
|
ErrorAlert(str); |
1925 |
|
QuitEmulator(); |
1926 |
|
return; |
1928 |
|
} |
1929 |
|
|
1930 |
|
// For all other errors, jump into debugger (sort of...) |
1931 |
+ |
crash_reason = "SIGILL"; |
1932 |
|
if (!ready_for_signals) { |
1933 |
< |
printf("SIGILL\n"); |
1934 |
< |
printf(" sigcontext %p, pt_regs %p\n", sc, r); |
1933 |
> |
printf("%s\n"); |
1934 |
> |
printf(" sigcontext %p, machine_regs %p\n", scp, r); |
1935 |
|
printf( |
1936 |
|
" pc %08lx lr %08lx ctr %08lx msr %08lx\n" |
1937 |
|
" xer %08lx cr %08lx \n" |
1943 |
|
" r20 %08lx r21 %08lx r22 %08lx r23 %08lx\n" |
1944 |
|
" r24 %08lx r25 %08lx r26 %08lx r27 %08lx\n" |
1945 |
|
" r28 %08lx r29 %08lx r30 %08lx r31 %08lx\n", |
1946 |
< |
r->nip, r->link, r->ctr, r->msr, |
1947 |
< |
r->xer, r->ccr, |
1948 |
< |
r->gpr[0], r->gpr[1], r->gpr[2], r->gpr[3], |
1949 |
< |
r->gpr[4], r->gpr[5], r->gpr[6], r->gpr[7], |
1950 |
< |
r->gpr[8], r->gpr[9], r->gpr[10], r->gpr[11], |
1951 |
< |
r->gpr[12], r->gpr[13], r->gpr[14], r->gpr[15], |
1952 |
< |
r->gpr[16], r->gpr[17], r->gpr[18], r->gpr[19], |
1953 |
< |
r->gpr[20], r->gpr[21], r->gpr[22], r->gpr[23], |
1954 |
< |
r->gpr[24], r->gpr[25], r->gpr[26], r->gpr[27], |
1955 |
< |
r->gpr[28], r->gpr[29], r->gpr[30], r->gpr[31]); |
1946 |
> |
crash_reason, |
1947 |
> |
r->pc(), r->lr(), r->ctr(), r->msr(), |
1948 |
> |
r->xer(), r->cr(), |
1949 |
> |
r->gpr(0), r->gpr(1), r->gpr(2), r->gpr(3), |
1950 |
> |
r->gpr(4), r->gpr(5), r->gpr(6), r->gpr(7), |
1951 |
> |
r->gpr(8), r->gpr(9), r->gpr(10), r->gpr(11), |
1952 |
> |
r->gpr(12), r->gpr(13), r->gpr(14), r->gpr(15), |
1953 |
> |
r->gpr(16), r->gpr(17), r->gpr(18), r->gpr(19), |
1954 |
> |
r->gpr(20), r->gpr(21), r->gpr(22), r->gpr(23), |
1955 |
> |
r->gpr(24), r->gpr(25), r->gpr(26), r->gpr(27), |
1956 |
> |
r->gpr(28), r->gpr(29), r->gpr(30), r->gpr(31)); |
1957 |
|
exit(1); |
1958 |
|
QuitEmulator(); |
1959 |
|
return; |
1960 |
|
} else { |
1961 |
|
// We crashed. Save registers, tell tick thread and loop forever |
1962 |
< |
sigsegv_regs = *(sigregs *)r; |
1962 |
> |
build_sigregs(&sigsegv_regs, r); |
1963 |
|
emul_thread_fatal = true; |
1964 |
|
for (;;) ; |
1965 |
|
} |
1974 |
|
|
1975 |
|
bool SheepMem::Init(void) |
1976 |
|
{ |
1977 |
+ |
// Size of a native page |
1978 |
+ |
page_size = getpagesize(); |
1979 |
+ |
|
1980 |
+ |
// Allocate SheepShaver globals |
1981 |
|
if (vm_acquire_fixed((char *)base, size) < 0) |
1982 |
|
return false; |
1983 |
|
|
1984 |
+ |
// Allocate page with all bits set to 0 |
1985 |
|
zero_page = base + size; |
1780 |
– |
|
1781 |
– |
int page_size = getpagesize(); |
1986 |
|
if (vm_acquire_fixed((char *)zero_page, page_size) < 0) |
1987 |
|
return false; |
1988 |
|
memset((char *)zero_page, 0, page_size); |
1989 |
|
if (vm_protect((char *)zero_page, page_size, VM_PAGE_READ) < 0) |
1990 |
|
return false; |
1991 |
|
|
1992 |
+ |
#if EMULATED_PPC |
1993 |
+ |
// Allocate alternate stack for PowerPC interrupt routine |
1994 |
+ |
sig_stack = zero_page + page_size; |
1995 |
+ |
if (vm_acquire_fixed((char *)sig_stack, SIG_STACK_SIZE) < 0) |
1996 |
+ |
return false; |
1997 |
+ |
#endif |
1998 |
+ |
|
1999 |
|
top = base + size; |
2000 |
|
return true; |
2001 |
|
} |
2003 |
|
void SheepMem::Exit(void) |
2004 |
|
{ |
2005 |
|
if (top) { |
2006 |
< |
// The zero page is next to SheepShaver globals |
2007 |
< |
vm_release((void *)base, size + getpagesize()); |
2006 |
> |
// Delete SheepShaver globals |
2007 |
> |
vm_release((void *)base, size); |
2008 |
> |
|
2009 |
> |
// Delete zero page |
2010 |
> |
vm_release((void *)zero_page, page_size); |
2011 |
> |
|
2012 |
> |
#if EMULATED_PPC |
2013 |
> |
// Delete alternate stack for PowerPC interrupt routine |
2014 |
> |
vm_release((void *)sig_stack, SIG_STACK_SIZE); |
2015 |
> |
#endif |
2016 |
|
} |
2017 |
|
} |
2018 |
|
|