ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/SheepShaver/src/BeOS/main_beos.cpp

Comparing SheepShaver/src/BeOS/main_beos.cpp (file contents):
Revision 1.9 by gbeauche, 2004-01-07T18:24:44Z vs.
Revision 1.22 by asvitkine, 2009-08-26T00:11:56Z

#	Line 1 | Line 1
1		/*
2		*  main_beos.cpp - Emulation core, BeOS implementation
3		*
4	<	*  SheepShaver (C) 1997-2002 Christian Bauer and Marc Hellwig
4	>	*  SheepShaver (C) 1997-2008 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
#	Line 74 | Line 74
74		#include "xpram.h"
75		#include "timer.h"
76		#include "adb.h"
77	–	#include "sony.h"
78	–	#include "disk.h"
79	–	#include "cdrom.h"
80	–	#include "scsi.h"
77		#include "video.h"
82	–	#include "audio.h"
83	–	#include "ether.h"
84	–	#include "serial.h"
85	–	#include "clip.h"
86	–	#include "extfs.h"
78		#include "sys.h"
79		#include "macos_util.h"
80		#include "rom_patches.h"
81		#include "user_strings.h"
91	–	#include "thunks.h"
82
83		#include "sheep_driver.h"
84
#	Line 117 | Line 107 | const char KERNEL_AREA2_NAME[] = "Macint
107		const char RAM_AREA_NAME[] = "Macintosh RAM";
108		const char ROM_AREA_NAME[] = "Macintosh ROM";
109		const char DR_CACHE_AREA_NAME[] = "Macintosh DR Cache";
110	+	const char DR_EMULATOR_AREA_NAME[] = "Macintosh DR Emulator";
111		const char SHEEP_AREA_NAME[] = "SheepShaver Virtual Stack";
112
113	+	const uintptr ROM_BASE = 0x40800000;            // Base address of ROM
114	+
115		const uint32 SIG_STACK_SIZE = 8192;                     // Size of signal stack
116
117		const uint32 MSG_START = 'strt';                        // Emulator start message
#	Line 142 | Line 135 | public:
135		// Initialize other variables
136		sheep_fd = -1;
137		emulator_data = NULL;
138	<	kernel_area = kernel_area2 = rom_area = ram_area = dr_cache_area = -1;
138	>	kernel_area = kernel_area2 = rom_area = ram_area = dr_cache_area = dr_emulator_area = -1;
139		emul_thread = nvram_thread = tick_thread = -1;
140		ReadyForSignals = false;
141		AllowQuitting = true;
#	Line 190 | Line 183 | private:
183		area_id rom_area;               // ROM area ID
184		area_id ram_area;               // RAM area ID
185		area_id dr_cache_area;  // DR Cache area ID
186	+	area_id dr_emulator_area;       // DR Emulator area ID
187
188		struct sigaction sigusr1_action;        // Interrupt signal (of emulator thread)
189		struct sigaction sigsegv_action;        // Data access exception signal (of emulator thread)
#	Line 210 | Line 204 | void *TOC;                             // TOC pointer
204		#endif
205		uint32 RAMBase;                 // Base address of Mac RAM
206		uint32 RAMSize;                 // Size of Mac RAM
207	+	uint32 ROMBase;                 // Base address of Mac ROM
208		uint32 KernelDataAddr;  // Address of Kernel Data
209		uint32 BootGlobsAddr;   // Address of BootGlobs structure at top of Mac RAM
210		uint32 DRCacheAddr;             // Address of DR Cache
211	+	uint32 DREmulatorAddr;  // Address of DR Emulator
212		uint32 PVR;                             // Theoretical PVR
213		int64 CPUClockSpeed;    // Processor clock speed (Hz)
214		int64 BusClockSpeed;    // Bus clock speed (Hz)
215	+	int64 TimebaseSpeed;    // Timebase clock speed (Hz)
216		system_info SysInfo;    // System information
217	+	uint8 *RAMBaseHost;             // Base address of Mac RAM (host address space)
218	+	uint8 *ROMBaseHost;             // Base address of Mac ROM (host address space)
219
220		static void *sig_stack = NULL;          // Stack for signal handlers
221		static void *extra_stack = NULL;        // Stack for SIGSEGV inside interrupt handler
222	+	uint32  SheepMem::page_size;            // Size of a native page
223		uintptr SheepMem::zero_page = 0;        // Address of ro page filled in with zeros
224		uintptr SheepMem::base;                         // Address of SheepShaver data
225	<	uintptr SheepMem::top;                          // Top of SheepShaver data (stack like storage)
225	>	uintptr SheepMem::proc;                         // Bottom address of SheepShave procedures
226	>	uintptr SheepMem::data;                         // Top of SheepShaver data (stack like storage)
227		static area_id SheepMemArea;            // SheepShaver data area ID
228
229
#	Line 295 | Line 296 | void SheepShaver::ReadyToRun(void)
296		}
297		CPUClockSpeed = SysInfo.cpu_clock_speed;
298		BusClockSpeed = SysInfo.bus_clock_speed;
299	+	TimebaseSpeed = BusClockSpeed / 4;
300
301		// Delete old areas
302		area_id old_kernel_area = find_area(KERNEL_AREA_NAME);
#	Line 312 | Line 314 | void SheepShaver::ReadyToRun(void)
314		area_id old_dr_cache_area = find_area(DR_CACHE_AREA_NAME);
315		if (old_dr_cache_area > 0)
316		delete_area(old_dr_cache_area);
317	+	area_id old_dr_emulator_area = find_area(DR_EMULATOR_AREA_NAME);
318	+	if (old_dr_emulator_area > 0)
319	+	delete_area(old_dr_emulator_area);
320
321		// Read preferences
322		int argc = 0;
323		char **argv = NULL;
324	<	PrefsInit(argc, argv);
324	>	PrefsInit(NULL, argc, argv);
325
326		// Init system routines
327		SysInit();
#	Line 359 | Line 364 | void SheepShaver::MessageReceived(BMessa
364		void SheepShaver::StartEmulator(void)
365		{
366		char str[256];
362	–	int16 i16;
367
368		// Open sheep driver and remap low memory
369		sheep_fd = open("/dev/sheep", 0);
#	Line 402 | Line 406 | void SheepShaver::StartEmulator(void)
406
407		// Create area for SheepShaver data
408		if (!SheepMem::Init()) {
409	<	sprintf(str, GetString(STR_NO_SHEEP_MEM_AREA_ERR));
409	>	sprintf(str, GetString(STR_NO_SHEEP_MEM_AREA_ERR), strerror(SheepMemArea), SheepMemArea);
410		ErrorAlert(str);
411		PostMessage(B_QUIT_REQUESTED);
412		return;
#	Line 423 | Line 427 | void SheepShaver::StartEmulator(void)
427		PostMessage(B_QUIT_REQUESTED);
428		return;
429		}
430	<	D(bug("RAM area %ld at %p\n", ram_area, RAMBase));
430	>	RAMBaseHost = (uint8 *)RAMBase
431	>	D(bug("RAM area %ld at %p\n", ram_area, RAMBaseHost));
432
433		// Create area and load Mac ROM
434		try {
#	Line 457 | Line 462 | void SheepShaver::StartEmulator(void)
462		}
463		D(bug("DR Cache area %ld at %p\n", dr_cache_area, DRCacheAddr));
464
465	<	// Load NVRAM
466	<	XPRAMInit();
467	<
468	<	// Set boot volume
469	<	i16 = PrefsFindInt32("bootdrive");
470	<	XPRAM[0x1378] = i16 >> 8;
466	<	XPRAM[0x1379] = i16 & 0xff;
467	<	i16 = PrefsFindInt32("bootdriver");
468	<	XPRAM[0x137a] = i16 >> 8;
469	<	XPRAM[0x137b] = i16 & 0xff;
470	<
471	<	// Create BootGlobs at top of Mac memory
472	<	memset((void *)(RAMBase + RAMSize - 4096), 0, 4096);
473	<	BootGlobsAddr = RAMBase + RAMSize - 0x1c;
474	<	uint32 *boot_globs = (uint32 *)BootGlobsAddr;
475	<	boot_globs[-5] = htonl(RAMBase + RAMSize);              // MemTop
476	<	boot_globs[0] = htonl(RAMBase);                                 // First RAM bank
477	<	boot_globs[1] = htonl(RAMSize);
478	<	boot_globs[2] = htonl((uint32)-1);                              // End of bank table
479	<
480	<	// Init thunks
481	<	if (!InitThunks()) {
482	<	PostMessage(B_QUIT_REQUESTED);
483	<	return;
484	<	}
485	<
486	<	// Init drivers
487	<	SonyInit();
488	<	DiskInit();
489	<	CDROMInit();
490	<	SCSIInit();
491	<
492	<	// Init external file system
493	<	ExtFSInit();
494	<
495	<	// Init audio
496	<	AudioInit();
497	<
498	<	// Init network
499	<	EtherInit();
500	<
501	<	// Init serial ports
502	<	SerialInit();
503	<
504	<	// Init Time Manager
505	<	TimerInit();
506	<
507	<	// Init clipboard
508	<	ClipInit();
509	<
510	<	// Init video
511	<	if (!VideoInit()) {
465	>	// Create area for DR Emulator
466	>	DREmulatorAddr = DR_EMULATOR_BASE;
467	>	dr_emulator_area = create_area(DR_EMULATOR_AREA_NAME, (void **)&DREmulatorAddr, B_EXACT_ADDRESS, DR_EMULATOR_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);
468	>	if (dr_emulator_area < 0) {
469	>	sprintf(str, GetString(STR_NO_KERNEL_DATA_ERR), strerror(dr_emulator_area), dr_emulator_area);
470	>	ErrorAlert(str);
471		PostMessage(B_QUIT_REQUESTED);
472		return;
473		}
474	+	D(bug("DR Emulator area %ld at %p\n", dr_emulator_area, DREmulatorAddr));
475
476	<	// Install ROM patches
477	<	if (!PatchROM()) {
518	<	ErrorAlert(GetString(STR_UNSUPPORTED_ROM_TYPE_ERR));
476	>	// Initialize everything
477	>	if (!InitAll()) {
478		PostMessage(B_QUIT_REQUESTED);
479		return;
480		}
481	+	D(bug("Initialization complete\n"));
482
483		// Clear caches (as we loaded and patched code) and write protect ROM
484		#if !EMULATED_PPC
485	<	clear_caches((void *)ROM_BASE, ROM_AREA_SIZE, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE);
485	>	clear_caches(ROMBaseHost, ROM_AREA_SIZE, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE);
486		#endif
487		set_area_protection(rom_area, B_READ_AREA);
488
529	–	// Initialize Kernel Data
530	–	memset(kernel_data, 0, sizeof(KernelData));
531	–	if (ROMType == ROMTYPE_NEWWORLD) {
532	–	static uint32 of_dev_tree[4] = {0, 0, 0, 0};
533	–	static uint8 vector_lookup_tbl[128];
534	–	static uint8 vector_mask_tbl[64];
535	–	memset((uint8 *)kernel_data + 0xb80, 0x3d, 0x80);
536	–	memset(vector_lookup_tbl, 0, 128);
537	–	memset(vector_mask_tbl, 0, 64);
538	–	kernel_data->v[0xb80 >> 2] = htonl(ROM_BASE);
539	–	kernel_data->v[0xb84 >> 2] = htonl((uint32)of_dev_tree);        // OF device tree base
540	–	kernel_data->v[0xb90 >> 2] = htonl((uint32)vector_lookup_tbl);
541	–	kernel_data->v[0xb94 >> 2] = htonl((uint32)vector_mask_tbl);
542	–	kernel_data->v[0xb98 >> 2] = htonl(ROM_BASE);                           // OpenPIC base
543	–	kernel_data->v[0xbb0 >> 2] = htonl(0);                                          // ADB base
544	–	kernel_data->v[0xc20 >> 2] = htonl(RAMSize);
545	–	kernel_data->v[0xc24 >> 2] = htonl(RAMSize);
546	–	kernel_data->v[0xc30 >> 2] = htonl(RAMSize);
547	–	kernel_data->v[0xc34 >> 2] = htonl(RAMSize);
548	–	kernel_data->v[0xc38 >> 2] = htonl(0x00010020);
549	–	kernel_data->v[0xc3c >> 2] = htonl(0x00200001);
550	–	kernel_data->v[0xc40 >> 2] = htonl(0x00010000);
551	–	kernel_data->v[0xc50 >> 2] = htonl(RAMBase);
552	–	kernel_data->v[0xc54 >> 2] = htonl(RAMSize);
553	–	kernel_data->v[0xf60 >> 2] = htonl(PVR);
554	–	kernel_data->v[0xf64 >> 2] = htonl(CPUClockSpeed);
555	–	kernel_data->v[0xf68 >> 2] = htonl(BusClockSpeed);
556	–	kernel_data->v[0xf6c >> 2] = htonl(CPUClockSpeed);
557	–	} else {
558	–	kernel_data->v[0xc80 >> 2] = htonl(RAMSize);
559	–	kernel_data->v[0xc84 >> 2] = htonl(RAMSize);
560	–	kernel_data->v[0xc90 >> 2] = htonl(RAMSize);
561	–	kernel_data->v[0xc94 >> 2] = htonl(RAMSize);
562	–	kernel_data->v[0xc98 >> 2] = htonl(0x00010020);
563	–	kernel_data->v[0xc9c >> 2] = htonl(0x00200001);
564	–	kernel_data->v[0xca0 >> 2] = htonl(0x00010000);
565	–	kernel_data->v[0xcb0 >> 2] = htonl(RAMBase);
566	–	kernel_data->v[0xcb4 >> 2] = htonl(RAMSize);
567	–	kernel_data->v[0xf80 >> 2] = htonl(PVR);
568	–	kernel_data->v[0xf84 >> 2] = htonl(CPUClockSpeed);
569	–	kernel_data->v[0xf88 >> 2] = htonl(BusClockSpeed);
570	–	kernel_data->v[0xf8c >> 2] = htonl(CPUClockSpeed);
571	–	}
572	–
489		// Initialize extra low memory
490	<	D(bug("Initializing Low Memory...\n"));
575	<	memset(NULL, 0, 0x3000);
576	<	WriteMacInt32(XLM_SIGNATURE, 'Baah');                                                   // Signature to detect SheepShaver
577	<	WriteMacInt32(XLM_KERNEL_DATA, (uint32)kernel_data);                    // For trap replacement routines
490	>	D(bug("Initializing extra Low Memory...\n"));
491		WriteMacInt32(XLM_SHEEP_OBJ, (uint32)this);                                             // Pointer to SheepShaver object
492	<	WriteMacInt32(XLM_PVR, PVR);                                                                    // Theoretical PVR
580	<	WriteMacInt32(XLM_BUS_CLOCK, BusClockSpeed);                                    // For DriverServicesLib patch
581	<	WriteMacInt16(XLM_EXEC_RETURN_OPCODE, M68K_EXEC_RETURN);                // For Execute68k() (RTS from the executed 68k code will jump here and end 68k mode)
582	<	WriteMacInt32(XLM_ZERO_PAGE, SheepMem::ZeroPage());                             // Pointer to read-only page with all bits set to 0
583	<	#if !EMULATED_PPC
584	<	WriteMacInt32(XLM_TOC, (uint32)TOC);                                                    // TOC pointer of emulator
585	<	WriteMacInt32(XLM_ETHER_INIT, *(uint32 *)InitStreamModule);             // DLPI ethernet driver functions
586	<	WriteMacInt32(XLM_ETHER_TERM, *(uint32 *)TerminateStreamModule);
587	<	WriteMacInt32(XLM_ETHER_OPEN, *(uint32 *)ether_open);
588	<	WriteMacInt32(XLM_ETHER_CLOSE, *(uint32 *)ether_close);
589	<	WriteMacInt32(XLM_ETHER_WPUT, *(uint32 *)ether_wput);
590	<	WriteMacInt32(XLM_ETHER_RSRV, *(uint32 *)ether_rsrv);
591	<	WriteMacInt32(XLM_VIDEO_DOIO, *(uint32 *)VideoDoDriverIO);
592	<	#endif
593	<	D(bug("Low Memory initialized\n"));
492	>	D(bug("Extra Low Memory initialized\n"));
493
494		// Disallow quitting with Alt-Q from now on
495		AllowQuitting = false;
#	Line 646 | Line 545 | void SheepShaver::Quit(void)
545		if (emul_thread > 0)
546		wait_for_thread(emul_thread, &l);
547
548	<	// Save NVRAM
549	<	XPRAMExit();
651	<
652	<	// Exit clipboard
653	<	ClipExit();
654	<
655	<	// Exit Time Manager
656	<	TimerExit();
657	<
658	<	// Exit serial
659	<	SerialExit();
660	<
661	<	// Exit network
662	<	EtherExit();
663	<
664	<	// Exit audio
665	<	AudioExit();
666	<
667	<	// Exit video
668	<	VideoExit();
669	<
670	<	// Exit external file system
671	<	ExtFSExit();
672	<
673	<	// Exit drivers
674	<	SCSIExit();
675	<	CDROMExit();
676	<	DiskExit();
677	<	SonyExit();
678	<
679	<	// Delete thunks
680	<	ThunksExit();
548	>	// Deinitialize everything
549	>	ExitAll();
550
551		// Delete SheepShaver globals
552		SheepMem::Exit();
553
554	+	// Delete DR Emulator area
555	+	if (dr_emulator_area >= 0)
556	+	delete_area(dr_emulator_area);
557	+
558		// Delete DR Cache area
559		if (dr_cache_area >= 0)
560		delete_area(dr_cache_area);
#	Line 726 | Line 599 | void SheepShaver::Quit(void)
599
600		void SheepShaver::init_rom(void)
601		{
602	+	// Size of a native page
603	+	page_size = B_PAGE_SIZE;
604	+
605		// Create area for ROM
606	<	void *rom_addr = (void *)ROM_BASE;
607	<	rom_area = create_area(ROM_AREA_NAME, &rom_addr, B_EXACT_ADDRESS, ROM_AREA_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);
606	>	ROMBase = ROM_BASE;
607	>	rom_area = create_area(ROM_AREA_NAME, (void **)&ROMBase, B_EXACT_ADDRESS, ROM_AREA_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);
608		if (rom_area < 0)
609		throw area_error();
610	+	ROMBaseHost = (uint8 *)ROMBase;
611		D(bug("ROM area %ld at %p\n", rom_area, rom_addr));
612
613		// Load ROM
#	Line 751 | Line 628 | void SheepShaver::load_rom(void)
628		const char *rom_path = PrefsFindString("rom");
629
630		// Try to open ROM file
631	<	BFile file(rom_path ? rom_path : ROM_FILE_NAME, B_READ_ONLY);
631	>	BFile file(rom_path && *rom_path ? rom_path : ROM_FILE_NAME, B_READ_ONLY);
632		if (file.InitCheck() != B_NO_ERROR) {
633
634		// Failed, then ask memory_mess driver for ROM
635		uint8 *rom = new uint8[ROM_SIZE];       // Reading directly into the area doesn't work
636		ssize_t actual = read(sheep_fd, (void *)rom, ROM_SIZE);
637		if (actual == ROM_SIZE) {
638	<	memcpy((void *)ROM_BASE, rom, ROM_SIZE);
638	>	memcpy(ROMBaseHost, rom, ROM_SIZE);
639		delete[] rom;
640		return;
641		} else
#	Line 829 | Line 706 | status_t SheepShaver::emul_func(void *ar
706
707		// Jump to ROM boot routine
708		D(bug("Jumping to ROM\n"));
709	<	obj->jump_to_rom(ROM_BASE + 0x310000);
709	>	obj->jump_to_rom(ROMBase + 0x310000);
710		D(bug("Returned from ROM\n"));
711
712		// We're no longer ready to receive signals
#	Line 1310 | Line 1187 | void Dump68kRegs(M68kRegisters *r)
1187		*  Make code executable
1188		*/
1189
1190	<	void MakeExecutable(int dummy, void *start, uint32 length)
1190	>	void MakeExecutable(int dummy, uint32 start, uint32 length)
1191		{
1192	<	if (((uint32)start >= ROM_BASE) && ((uint32)start < (ROM_BASE + ROM_SIZE)))
1192	>	if ((start >= ROMBase) && (start < (ROMBase + ROM_SIZE)))
1193		return;
1194	<	clear_caches(start, length, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE);
1318	<	}
1319	<
1320	<
1321	<	/*
1322	<	*  Patch things after system startup (gets called by disk driver accRun routine)
1323	<	*/
1324	<
1325	<	void PatchAfterStartup(void)
1326	<	{
1327	<	ExecuteNative(NATIVE_VIDEO_INSTALL_ACCEL);
1328	<	InstallExtFS();
1194	>	clear_caches((void *)start, length, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE);
1195		}
1196
1197
#	Line 1386 | Line 1252 | status_t SheepShaver::tick_func(void *ar
1252
1253		void TriggerInterrupt(void)
1254		{
1255	+	idle_resume();
1256		#if 0
1257		WriteMacInt32(0x16a, ReadMacInt32(0x16a) + 1);
1258		#else
#	Line 1537 | Line 1404 | void SheepShaver::sigusr1_handler(vregs
1404		// Execute nanokernel interrupt routine (this will activate the 68k emulator)
1405		atomic_add((int32 *)XLM_IRQ_NEST, 1);
1406		if (ROMType == ROMTYPE_NEWWORLD)
1407	<	ppc_interrupt(ROM_BASE + 0x312b1c);
1407	>	ppc_interrupt(ROMBase + 0x312b1c);
1408		else
1409	<	ppc_interrupt(ROM_BASE + 0x312a3c);
1409	>	ppc_interrupt(ROMBase + 0x312a3c);
1410		}
1411		break;
1412		#endif
#	Line 1643 | Line 1510 | static void sigsegv_handler(vregs *r)
1510		uint32 imm = opcode & 0xffff;
1511
1512		// Fault in Mac ROM or RAM?
1513	<	bool mac_fault = (r->pc >= ROM_BASE) && (r->pc < (ROM_BASE + ROM_AREA_SIZE)) || (r->pc >= RAMBase) && (r->pc < (RAMBase + RAMSize));
1513	>	bool mac_fault = (r->pc >= ROMBase) && (r->pc < (ROMBase + ROM_AREA_SIZE)) || (r->pc >= RAMBase) && (r->pc < (RAMBase + RAMSize));
1514		if (mac_fault) {
1515
1516		// "VM settings" during MacOS 8 installation
1517	<	if (r->pc == ROM_BASE + 0x488160 && segv_r[20] == 0xf8000000) {
1517	>	if (r->pc == ROMBase + 0x488160 && segv_r[20] == 0xf8000000) {
1518		r->pc += 4;
1519		segv_r[8] = 0;
1520		goto rti;
1521
1522		// MacOS 8.5 installation
1523	<	} else if (r->pc == ROM_BASE + 0x488140 && segv_r[16] == 0xf8000000) {
1523	>	} else if (r->pc == ROMBase + 0x488140 && segv_r[16] == 0xf8000000) {
1524		r->pc += 4;
1525		segv_r[8] = 0;
1526		goto rti;
1527
1528		// MacOS 8 serial drivers on startup
1529	<	} else if (r->pc == ROM_BASE + 0x48e080 && (segv_r[8] == 0xf3012002 || segv_r[8] == 0xf3012000)) {
1529	>	} else if (r->pc == ROMBase + 0x48e080 && (segv_r[8] == 0xf3012002 || segv_r[8] == 0xf3012000)) {
1530		r->pc += 4;
1531		segv_r[8] = 0;
1532		goto rti;
1533
1534		// MacOS 8.1 serial drivers on startup
1535	<	} else if (r->pc == ROM_BASE + 0x48c5e0 && (segv_r[20] == 0xf3012002 || segv_r[20] == 0xf3012000)) {
1535	>	} else if (r->pc == ROMBase + 0x48c5e0 && (segv_r[20] == 0xf3012002 || segv_r[20] == 0xf3012000)) {
1536		r->pc += 4;
1537		goto rti;
1538	<	} else if (r->pc == ROM_BASE + 0x4a10a0 && (segv_r[20] == 0xf3012002 || segv_r[20] == 0xf3012000)) {
1538	>	} else if (r->pc == ROMBase + 0x4a10a0 && (segv_r[20] == 0xf3012002 || segv_r[20] == 0xf3012000)) {
1539		r->pc += 4;
1540		goto rti;
1541		}
#	Line 1779 | Line 1646 | static void sigsegv_handler(vregs *r)
1646		}
1647
1648		// Ignore ROM writes
1649	<	if (transfer_type == TYPE_STORE && addr >= ROM_BASE && addr < ROM_BASE + ROM_SIZE) {
1649	>	if (transfer_type == TYPE_STORE && addr >= ROMBase && addr < ROMBase + ROM_SIZE) {
1650		D(bug("WARNING: %s write access to ROM at %p, pc %p\n", transfer_size == SIZE_BYTE ? "Byte" : transfer_size == SIZE_HALFWORD ? "Halfword" : "Word", addr, r->pc));
1651		if (addr_mode == MODE_U || addr_mode == MODE_UX)
1652		segv_r[ra] = addr;
#	Line 1914 | Line 1781 | static void sigill_handler(vregs *r)
1781		uint32 imm = opcode & 0xffff;
1782
1783		// Fault in Mac ROM or RAM?
1784	<	bool mac_fault = (r->pc >= ROM_BASE) && (r->pc < (ROM_BASE + ROM_AREA_SIZE)) || (r->pc >= RAMBase) && (r->pc < (RAMBase + RAMSize));
1784	>	bool mac_fault = (r->pc >= ROMBase) && (r->pc < (ROMBase + ROM_AREA_SIZE)) || (r->pc >= RAMBase) && (r->pc < (RAMBase + RAMSize));
1785		if (mac_fault) {
1786
1787		switch (primop) {
#	Line 2079 | Line 1946 | bool SheepMem::Init(void)
1946		delete_area(old_sheep_area);
1947
1948		// Create area for SheepShaver data
1949	<	base = 0x60000000;
1949	>	proc = base = 0x60000000;
1950		SheepMemArea = create_area(SHEEP_AREA_NAME, (void **)&base, B_BASE_ADDRESS, size, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);
1951		if (SheepMemArea < 0)
1952		return false;
#	Line 2089 | Line 1956 | bool SheepMem::Init(void)
1956		zero_page = const_zero_page;
1957
1958		D(bug("SheepShaver area %ld at %p\n", SheepMemArea, base));
1959	<	top = base + size;
1959	>	data = base + size;
1960		return true;
1961		}
1962

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines