diff --git a/SheepShaver/src/BeOS/main_beos.cpp b/SheepShaver/src/BeOS/main_beos.cpp index f994510f..99352882 100644 --- a/SheepShaver/src/BeOS/main_beos.cpp +++ b/SheepShaver/src/BeOS/main_beos.cpp @@ -221,6 +221,8 @@ int64 CPUClockSpeed; // Processor clock speed (Hz) int64 BusClockSpeed; // Bus clock speed (Hz) int64 TimebaseSpeed; // Timebase clock speed (Hz) system_info SysInfo; // System information +uint8 *RAMBaseHost; // Base address of Mac RAM (host address space) +uint8 *ROMBaseHost; // Base address of Mac ROM (host address space) static void *sig_stack = NULL; // Stack for signal handlers static void *extra_stack = NULL; // Stack for SIGSEGV inside interrupt handler @@ -432,7 +434,8 @@ void SheepShaver::StartEmulator(void) PostMessage(B_QUIT_REQUESTED); return; } - D(bug("RAM area %ld at %p\n", ram_area, RAMBase)); + RAMBaseHost = (uint8 *)RAMBase + D(bug("RAM area %ld at %p\n", ram_area, RAMBaseHost)); // Create area and load Mac ROM try { @@ -542,7 +545,7 @@ void SheepShaver::StartEmulator(void) // Clear caches (as we loaded and patched code) and write protect ROM #if !EMULATED_PPC - clear_caches((void *)ROM_BASE, ROM_AREA_SIZE, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE); + clear_caches(ROMBaseHost, ROM_AREA_SIZE, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE); #endif set_area_protection(rom_area, B_READ_AREA); @@ -754,8 +757,8 @@ void SheepShaver::init_rom(void) page_size = B_PAGE_SIZE; // Create area for ROM - void *rom_addr = (void *)ROM_BASE; - rom_area = create_area(ROM_AREA_NAME, &rom_addr, B_EXACT_ADDRESS, ROM_AREA_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA); + ROMBaseHost = (uint8 *)ROM_BASE; + rom_area = create_area(ROM_AREA_NAME, (void **)&ROMBaseHost, B_EXACT_ADDRESS, ROM_AREA_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA); if (rom_area < 0) throw area_error(); D(bug("ROM area %ld at %p\n", rom_area, rom_addr)); @@ -1337,11 +1340,11 @@ void Dump68kRegs(M68kRegisters *r) * Make code executable */ -void MakeExecutable(int dummy, void *start, uint32 length) +void MakeExecutable(int dummy, uint32 start, uint32 length) { - if (((uint32)start >= ROM_BASE) && ((uint32)start < (ROM_BASE + ROM_SIZE))) + if ((start >= ROM_BASE) && (start < (ROM_BASE + ROM_SIZE))) return; - clear_caches(start, length, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE); + clear_caches((void *)start, length, B_INVALIDATE_ICACHE | B_FLUSH_DCACHE); } diff --git a/SheepShaver/src/BeOS/video_beos.cpp b/SheepShaver/src/BeOS/video_beos.cpp index 770af26a..ff4962e4 100644 --- a/SheepShaver/src/BeOS/video_beos.cpp +++ b/SheepShaver/src/BeOS/video_beos.cpp @@ -687,8 +687,8 @@ void VideoInstallAccel(void) // Install acceleration hooks if (PrefsFindBool("gfxaccel")) { D(bug("Video: Installing acceleration hooks\n")); - NQDMisc(6, &bitblt_hook_info); - NQDMisc(6, &fillrect_hook_info); + NQDMisc(6, (uintptr)&bitblt_hook_info); + NQDMisc(6, (uintptr)&fillrect_hook_info); } } diff --git a/SheepShaver/src/Unix/clip_unix.cpp b/SheepShaver/src/Unix/clip_unix.cpp index 5e464768..b4d34e6a 100644 --- a/SheepShaver/src/Unix/clip_unix.cpp +++ b/SheepShaver/src/Unix/clip_unix.cpp @@ -497,7 +497,7 @@ static void do_getscrap(void **handle, uint32 type, int32 offset) PW(0x588f), // addq.l #4,sp PW(M68K_RTS) }; - uint32 proc_area = (uint32)proc; + uint32 proc_area = Host2MacAddr((uint8 *)proc); WriteMacInt32(proc_area + 6, data.size()); WriteMacInt32(proc_area + 12, type); WriteMacInt32(proc_area + 18, scrap_area); diff --git a/SheepShaver/src/Unix/configure.ac b/SheepShaver/src/Unix/configure.ac index f6d933ae..5163762a 100644 --- a/SheepShaver/src/Unix/configure.ac +++ b/SheepShaver/src/Unix/configure.ac @@ -25,6 +25,17 @@ AC_ARG_WITH(gtk, [ --with-gtk use GTK user interface [d AC_ARG_WITH(mon, [ --with-mon use mon as debugger [default=yes]], [WANT_MON=$withval], [WANT_MON=yes]) AC_ARG_WITH(dgcc, [ --with-dgcc=COMPILER use C++ COMPILER to compile synthetic opcodes], [DYNGEN_CC=$withval]) +dnl Addressing mode +AC_ARG_ENABLE(addressing, + [ --enable-addressing=AM set the addressing mode to use [default=real]], + [case "$enableval" in + real) WANT_ADDRESSING_MODE="real";; + direct) WANT_ADDRESSING_MODE="direct";; + direct,0x*) WANT_ADDRESSING_MODE="direct"; NATMEM_OFFSET=`echo "$enableval" | sed -n '/direct,\(0[[xX]][[0-9A-Fa-f]]*\)/s//\1/p'`;; + esac], + [WANT_ADDRESSING_MODE="real"] +) + dnl SDL options. AC_ARG_ENABLE(sdl-static, [ --enable-sdl-static use SDL static libraries for linking [default=no]], [WANT_SDL_STATIC=$enableval], [WANT_SDL_STATIC=no]) AC_ARG_ENABLE(sdl-video, [ --enable-sdl-video use SDL for video graphics [default=no]], [WANT_SDL_VIDEO=$enableval], [WANT_SDL_VIDEO=no]) @@ -758,6 +769,87 @@ else WANT_VOSF=no fi +dnl Check addressing mode to use +AC_MSG_CHECKING([for addressing mode to use]) +if [[ "$EMULATED_PPC" != "yes" ]]; then + if [[ "$WANT_ADDRESSING_MODE" != "real" ]]; then + AC_MSG_WARN([Running in native PowerPC mode, force use of Real Addressing.]) + WANT_ADDRESSING_MODE="real" + fi +fi +if [[ "$WANT_ADDRESSING_MODE" = "direct" ]]; then + if [[ -n "$NATMEM_OFFSET" ]]; then + NATMEM_OFFSET_DEF="-DNATMEM_OFFSET=$NATMEM_OFFSET" + fi + AC_LANG_SAVE + AC_LANG_CPLUSPLUS + cat confdefs.h > conftest.$ac_ext + cat >> conftest.$ac_ext << EOF +#include +#include +#include "vm_alloc.cpp" + +int main(void) +{ + if (vm_init() < 0) + return 1; + + static const struct { + unsigned long base; + unsigned int size; + } ranges[[]] = { + { 0x00000000, 0x0003000 }, + { 0x10000000, 0x2000000 }, + { 0x40800000, 0x0400000 }, + { 0x68070000, 0x0010000 }, + { 0x69000000, 0x0080000 }, + { 0x68ffe000, 0x0002000 }, + { 0x5fffe000, 0x0002000 }, + { 0x60000000, 0x0040000 }, + }; + const int n_ranges = sizeof(ranges)/ sizeof(ranges[[0]]); + +#ifdef NATMEM_OFFSET + unsigned long ofs = NATMEM_OFFSET; +#else + for (unsigned long ofs = 0x10000000; ofs <= 0x90000000; ofs += 0x10000000) +#endif + for (int i = 0; i < n_ranges; i++) { + char *m = (char *)(ranges[[i]].base + ofs); + if (vm_acquire_fixed(m, ranges[[i]].size) != 0) + break; + memset(m, 0, ranges[[i]].size); + vm_release(m, ranges[[i]].size); + if (i == n_ranges - 1) { + printf("0x%08x\n", ofs); + return 0; + } + } + + vm_exit(); + return 1; +} +EOF + doit='$CXX conftest.$ac_ext -o conftest.$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS $LIBS $NATMEM_OFFSET_DEF >& AS_MESSAGE_LOG_FD' + if AC_TRY_EVAL(doit); then + NATMEM_OFFSET=`./conftest.$ac_exeext` + if [[ -z "$NATMEM_OFFSET" ]]; then + AC_MSG_ERROR([could not determine a sensible NATMEM_OFFSET value]) + else + WANT_ADDRESSING_MODE="direct,$NATMEM_OFFSET" + fi + fi + rm -f conftest* + AC_LANG_RESTORE +fi +AC_MSG_RESULT($WANT_ADDRESSING_MODE) + +if [[ -z "$NATMEM_OFFSET" ]]; then + NATMEM_OFFSET=0 +fi +AC_DEFINE_UNQUOTED(NATMEM_OFFSET, $NATMEM_OFFSET, + [Define constant offset for Mac address translation]) + dnl Platform specific binary postprocessor AC_PATH_PROG(BLESS, "true") if [[ "x$ac_cv_pagezero_hack" = "xyes" ]]; then @@ -791,7 +883,7 @@ if $CXX -V -v 2>&1 | grep -q "Intel(R) C++ Compiler"; then fi AC_MSG_RESULT($HAVE_ICC) -# Test if the compiler can generate ELF objects +dnl Test if the compiler can generate ELF objects AC_CACHE_CHECK([whether the compiler can generate ELF objects], ac_cv_elf_objects, [ echo 'int i;' > conftest.$ac_ext @@ -949,6 +1041,7 @@ echo Enable video on SEGV signals ..... : $WANT_VOSF echo ESD sound support ................ : $WANT_ESD echo GTK user interface ............... : $WANT_GTK echo mon debugger support ............. : $WANT_MON +echo Addressing mode .................. : $WANT_ADDRESSING_MODE echo Bad memory access recovery type .. : $sigsegv_recovery echo echo "Configuration done. Now type \"make\"." diff --git a/SheepShaver/src/Unix/main_unix.cpp b/SheepShaver/src/Unix/main_unix.cpp index ab644090..90c8cac0 100644 --- a/SheepShaver/src/Unix/main_unix.cpp +++ b/SheepShaver/src/Unix/main_unix.cpp @@ -174,7 +174,12 @@ const char ROM_FILE_NAME[] = "ROM"; const char ROM_FILE_NAME2[] = "Mac OS ROM"; +#if REAL_ADDRESSING const uintptr RAM_BASE = 0x20000000; // Base address of RAM +#else +// FIXME: needs to be >= 0x04000000 +const uintptr RAM_BASE = 0x10000000; // Base address of RAM +#endif const uint32 SIG_STACK_SIZE = 0x10000; // Size of signal stack @@ -280,6 +285,8 @@ uint32 PVR; // Theoretical PVR int64 CPUClockSpeed; // Processor clock speed (Hz) int64 BusClockSpeed; // Bus clock speed (Hz) int64 TimebaseSpeed; // Timebase clock speed (Hz) +uint8 *RAMBaseHost; // Base address of Mac RAM (host address space) +uint8 *ROMBaseHost; // Base address of Mac ROM (host address space) // Global variables @@ -431,7 +438,6 @@ static void usage(const char *prg_name) int main(int argc, char **argv) { char str[256]; - uint32 *boot_globs; int16 i16; int rom_fd; FILE *proc_file; @@ -763,7 +769,7 @@ int main(int argc, char **argv) #ifndef PAGEZERO_HACK // Create Low Memory area (0x0000..0x3000) - if (vm_acquire_fixed((char *)0, 0x3000) < 0) { + if (vm_acquire_fixed((char *)NATMEM_OFFSET, 0x3000) < 0) { sprintf(str, GetString(STR_LOW_MEM_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; @@ -778,29 +784,30 @@ int main(int argc, char **argv) ErrorAlert(str); goto quit; } - if (shmat(kernel_area, (void *)KERNEL_DATA_BASE, 0) < 0) { + if (shmat(kernel_area, (void *)(KERNEL_DATA_BASE + NATMEM_OFFSET), 0) < 0) { sprintf(str, GetString(STR_KD_SHMAT_ERR), strerror(errno)); ErrorAlert(str); goto quit; } - if (shmat(kernel_area, (void *)KERNEL_DATA2_BASE, 0) < 0) { + if (shmat(kernel_area, (void *)(KERNEL_DATA2_BASE + NATMEM_OFFSET), 0) < 0) { sprintf(str, GetString(STR_KD2_SHMAT_ERR), strerror(errno)); ErrorAlert(str); goto quit; } - kernel_data = (KernelData *)KERNEL_DATA_BASE; + kernel_data = (KernelData *)(KERNEL_DATA_BASE + NATMEM_OFFSET); emulator_data = &kernel_data->ed; KernelDataAddr = KERNEL_DATA_BASE; - D(bug("Kernel Data at %p, Emulator Data at %p\n", kernel_data, emulator_data)); + D(bug("Kernel Data at %p (%08x)\n", kernel_data, KERNEL_DATA_BASE)); + D(bug("Emulator Data at %p (%08x)\n", emulator_data, KERNEL_DATA_BASE + offsetof(KernelData, ed))); // Create area for DR Cache - if (vm_acquire_fixed((void *)DR_EMULATOR_BASE, DR_EMULATOR_SIZE) < 0) { + if (vm_acquire_fixed((void *)(DR_EMULATOR_BASE + NATMEM_OFFSET), DR_EMULATOR_SIZE) < 0) { sprintf(str, GetString(STR_DR_EMULATOR_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; } dr_emulator_area_mapped = true; - if (vm_acquire_fixed((void *)DR_CACHE_BASE, DR_CACHE_SIZE) < 0) { + if (vm_acquire_fixed((void *)(DR_CACHE_BASE + NATMEM_OFFSET), DR_CACHE_SIZE) < 0) { sprintf(str, GetString(STR_DR_CACHE_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; @@ -824,20 +831,21 @@ int main(int argc, char **argv) } // Create area for Mac ROM - if (vm_acquire_fixed((char *)ROM_BASE, ROM_AREA_SIZE) < 0) { + ROMBaseHost = (uint8 *)(ROM_BASE + NATMEM_OFFSET); + if (vm_acquire_fixed(ROMBaseHost, ROM_AREA_SIZE) < 0) { sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; } #if !EMULATED_PPC - if (vm_protect((char *)ROM_BASE, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) { + if (vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) { sprintf(str, GetString(STR_ROM_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; } #endif rom_area_mapped = true; - D(bug("ROM area at %08x\n", ROM_BASE)); + D(bug("ROM area at %p (%08x)\n", ROMBaseHost, ROM_BASE)); // Create area for Mac RAM RAMSize = PrefsFindInt32("ramsize"); @@ -846,13 +854,14 @@ int main(int argc, char **argv) RAMSize = 8*1024*1024; } - if (vm_acquire_fixed((char *)RAM_BASE, RAMSize) < 0) { + RAMBaseHost = (uint8 *)(RAM_BASE + NATMEM_OFFSET); + if (vm_acquire_fixed(RAMBaseHost, RAMSize) < 0) { sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; } #if !EMULATED_PPC - if (vm_protect((char *)RAM_BASE, RAMSize, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) { + if (vm_protect(RAMBaseHost, RAMSize, VM_PAGE_READ | VM_PAGE_WRITE | VM_PAGE_EXECUTE) < 0) { sprintf(str, GetString(STR_RAM_MMAP_ERR), strerror(errno)); ErrorAlert(str); goto quit; @@ -860,7 +869,7 @@ int main(int argc, char **argv) #endif RAMBase = RAM_BASE; ram_area_mapped = true; - D(bug("RAM area at %08x\n", RAMBase)); + D(bug("RAM area at %p (%08x)\n", RAMBaseHost, RAMBase)); if (RAMBase > ROM_BASE) { ErrorAlert(GetString(STR_RAM_HIGHER_THAN_ROM_ERR)); @@ -938,13 +947,12 @@ int main(int argc, char **argv) XPRAM[0x137b] = i16 & 0xff; // Create BootGlobs at top of Mac memory - memset((void *)(RAMBase + RAMSize - 4096), 0, 4096); + memset(RAMBaseHost + RAMSize - 4096, 0, 4096); BootGlobsAddr = RAMBase + RAMSize - 0x1c; - boot_globs = (uint32 *)BootGlobsAddr; - boot_globs[-5] = htonl(RAMBase + RAMSize); // MemTop - boot_globs[0] = htonl(RAMBase); // First RAM bank - boot_globs[1] = htonl(RAMSize); - boot_globs[2] = htonl((uint32)-1); // End of bank table + WriteMacInt32(BootGlobsAddr - 5 * 4, RAMBase + RAMSize); // MemTop + WriteMacInt32(BootGlobsAddr + 0 * 4, RAMBase); // First RAM bank + WriteMacInt32(BootGlobsAddr + 1 * 4, RAMSize); + WriteMacInt32(BootGlobsAddr + 2 * 4, (uint32)-1); // End of bank table // Init thunks if (!ThunksInit()) @@ -989,20 +997,20 @@ int main(int argc, char **argv) // Clear caches (as we loaded and patched code) and write protect ROM #if !EMULATED_PPC - MakeExecutable(0, (void *)ROM_BASE, ROM_AREA_SIZE); + MakeExecutable(0, ROM_BASE, ROM_AREA_SIZE); #endif - vm_protect((char *)ROM_BASE, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_EXECUTE); + vm_protect(ROMBaseHost, ROM_AREA_SIZE, VM_PAGE_READ | VM_PAGE_EXECUTE); // Initialize Kernel Data memset(kernel_data, 0, sizeof(KernelData)); if (ROMType == ROMTYPE_NEWWORLD) { - uintptr of_dev_tree = SheepMem::Reserve(4 * sizeof(uint32)); - memset((void *)of_dev_tree, 0, 4 * sizeof(uint32)); - uintptr vector_lookup_tbl = SheepMem::Reserve(128); - uintptr vector_mask_tbl = SheepMem::Reserve(64); + uint32 of_dev_tree = SheepMem::Reserve(4 * sizeof(uint32)); + Mac_memset(of_dev_tree, 0, 4 * sizeof(uint32)); + uint32 vector_lookup_tbl = SheepMem::Reserve(128); + uint32 vector_mask_tbl = SheepMem::Reserve(64); memset((uint8 *)kernel_data + 0xb80, 0x3d, 0x80); - memset((void *)vector_lookup_tbl, 0, 128); - memset((void *)vector_mask_tbl, 0, 64); + Mac_memset(vector_lookup_tbl, 0, 128); + Mac_memset(vector_mask_tbl, 0, 64); kernel_data->v[0xb80 >> 2] = htonl(ROM_BASE); kernel_data->v[0xb84 >> 2] = htonl(of_dev_tree); // OF device tree base kernel_data->v[0xb90 >> 2] = htonl(vector_lookup_tbl); @@ -1040,7 +1048,7 @@ int main(int argc, char **argv) // Initialize extra low memory D(bug("Initializing Low Memory...\n")); - memset(NULL, 0, 0x3000); + Mac_memset(0, 0, 0x3000); WriteMacInt32(XLM_SIGNATURE, FOURCC('B','a','a','h')); // Signature to detect SheepShaver WriteMacInt32(XLM_KERNEL_DATA, KernelDataAddr); // For trap replacement routines WriteMacInt32(XLM_PVR, PVR); // Theoretical PVR @@ -1200,28 +1208,28 @@ static void Quit(void) // Delete RAM area if (ram_area_mapped) - vm_release((char *)RAM_BASE, RAMSize); + vm_release(RAMBaseHost, RAMSize); // Delete ROM area if (rom_area_mapped) - vm_release((char *)ROM_BASE, ROM_AREA_SIZE); + vm_release(ROMBaseHost, ROM_AREA_SIZE); // Delete DR cache areas if (dr_emulator_area_mapped) - vm_release((void *)DR_EMULATOR_BASE, DR_EMULATOR_SIZE); + vm_release((void *)(DR_EMULATOR_BASE + NATMEM_OFFSET), DR_EMULATOR_SIZE); if (dr_cache_area_mapped) - vm_release((void *)DR_CACHE_BASE, DR_CACHE_SIZE); + vm_release((void *)(DR_CACHE_BASE + NATMEM_OFFSET), DR_CACHE_SIZE); // Delete Kernel Data area if (kernel_area >= 0) { - shmdt((void *)KERNEL_DATA_BASE); - shmdt((void *)KERNEL_DATA2_BASE); + shmdt((void *)(KERNEL_DATA_BASE + NATMEM_OFFSET)); + shmdt((void *)(KERNEL_DATA2_BASE + NATMEM_OFFSET)); shmctl(kernel_area, IPC_RMID, NULL); } // Delete Low Memory area if (lm_area_mapped) - munmap((char *)0x0000, 0x3000); + vm_release((void *)NATMEM_OFFSET, 0x3000); // Close /dev/zero if (zero_fd > 0) @@ -1377,14 +1385,14 @@ void Dump68kRegs(M68kRegisters *r) * Make code executable */ -void MakeExecutable(int dummy, void *start, uint32 length) +void MakeExecutable(int dummy, uint32 start, uint32 length) { - if (((uintptr)start >= ROM_BASE) && ((uintptr)start < (ROM_BASE + ROM_SIZE))) + if ((start >= ROM_BASE) && (start < (ROM_BASE + ROM_SIZE))) return; #if EMULATED_PPC - FlushCodeCache((uintptr)start, (uintptr)start + length); + FlushCodeCache(start, start + length); #else - flush_icache_range(start, (void *)((uintptr)start + length)); + flush_icache_range(start, (void *)(start + length)); #endif } @@ -2203,21 +2211,22 @@ bool SheepMem::Init(void) page_size = getpagesize(); // Allocate SheepShaver globals - if (vm_acquire_fixed((char *)base, size) < 0) + if (vm_acquire_fixed((char *)(base + NATMEM_OFFSET), size) < 0) return false; // Allocate page with all bits set to 0 zero_page = base + size; - if (vm_acquire_fixed((char *)zero_page, page_size) < 0) + uint8 *zero_page_host = (uint8 *)zero_page + NATMEM_OFFSET; + if (vm_acquire_fixed(zero_page_host, page_size) < 0) return false; - memset((char *)zero_page, 0, page_size); - if (vm_protect((char *)zero_page, page_size, VM_PAGE_READ) < 0) + memset(zero_page_host, 0, page_size); + if (vm_protect(zero_page_host, page_size, VM_PAGE_READ) < 0) return false; #if EMULATED_PPC // Allocate alternate stack for PowerPC interrupt routine sig_stack = zero_page + page_size; - if (vm_acquire_fixed((char *)sig_stack, SIG_STACK_SIZE) < 0) + if (vm_acquire_fixed((char *)(sig_stack + NATMEM_OFFSET), SIG_STACK_SIZE) < 0) return false; #endif @@ -2229,14 +2238,14 @@ void SheepMem::Exit(void) { if (top) { // Delete SheepShaver globals - vm_release((void *)base, size); + vm_release((void *)(base + NATMEM_OFFSET), size); // Delete zero page - vm_release((void *)zero_page, page_size); + vm_release((void *)(zero_page + NATMEM_OFFSET), page_size); #if EMULATED_PPC // Delete alternate stack for PowerPC interrupt routine - vm_release((void *)sig_stack, SIG_STACK_SIZE); + vm_release((void *)(sig_stack + NATMEM_OFFSET), SIG_STACK_SIZE); #endif } } diff --git a/SheepShaver/src/Unix/sysdeps.h b/SheepShaver/src/Unix/sysdeps.h index f388a0ad..ec2fa0ef 100644 --- a/SheepShaver/src/Unix/sysdeps.h +++ b/SheepShaver/src/Unix/sysdeps.h @@ -66,8 +66,13 @@ // Define for external components #define SHEEPSHAVER 1 -// Mac and host address space are the same +// Always use Real Addressing mode on native architectures +// Otherwise, use Direct Addressing mode if NATMEM_OFFSET is set +#if NATMEM_OFFSET == 0 || EMULATED_PPC == 0 #define REAL_ADDRESSING 1 +#else +#define DIRECT_ADDRESSING 1 +#endif #define POWERPC_ROM 1 @@ -413,14 +418,14 @@ extern X11_LOCK_TYPE x_display_lock; #endif // Macro for calling MacOS routines -#define CallMacOS(type, tvect) call_macos((uint32)tvect) -#define CallMacOS1(type, tvect, arg1) call_macos1((uint32)tvect, (uint32)arg1) -#define CallMacOS2(type, tvect, arg1, arg2) call_macos2((uint32)tvect, (uint32)arg1, (uint32)arg2) -#define CallMacOS3(type, tvect, arg1, arg2, arg3) call_macos3((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3) -#define CallMacOS4(type, tvect, arg1, arg2, arg3, arg4) call_macos4((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4) -#define CallMacOS5(type, tvect, arg1, arg2, arg3, arg4, arg5) call_macos5((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4, (uint32)arg5) -#define CallMacOS6(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6) call_macos6((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4, (uint32)arg5, (uint32)arg6) -#define CallMacOS7(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6, arg7) call_macos7((uint32)tvect, (uint32)arg1, (uint32)arg2, (uint32)arg3, (uint32)arg4, (uint32)arg5, (uint32)arg6, (uint32)arg7) +#define CallMacOS(type, tvect) call_macos((uintptr)tvect) +#define CallMacOS1(type, tvect, arg1) call_macos1((uintptr)tvect, (uintptr)arg1) +#define CallMacOS2(type, tvect, arg1, arg2) call_macos2((uintptr)tvect, (uintptr)arg1, (uintptr)arg2) +#define CallMacOS3(type, tvect, arg1, arg2, arg3) call_macos3((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3) +#define CallMacOS4(type, tvect, arg1, arg2, arg3, arg4) call_macos4((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4) +#define CallMacOS5(type, tvect, arg1, arg2, arg3, arg4, arg5) call_macos5((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4, (uintptr)arg5) +#define CallMacOS6(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6) call_macos6((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4, (uintptr)arg5, (uintptr)arg6) +#define CallMacOS7(type, tvect, arg1, arg2, arg3, arg4, arg5, arg6, arg7) call_macos7((uintptr)tvect, (uintptr)arg1, (uintptr)arg2, (uintptr)arg3, (uintptr)arg4, (uintptr)arg5, (uintptr)arg6, (uintptr)arg7) #ifdef __cplusplus extern "C" { diff --git a/SheepShaver/src/Unix/video_x.cpp b/SheepShaver/src/Unix/video_x.cpp index 5549d618..cb98afe7 100644 --- a/SheepShaver/src/Unix/video_x.cpp +++ b/SheepShaver/src/Unix/video_x.cpp @@ -503,7 +503,7 @@ static bool open_window(int width, int height) the_buffer = (uint8 *)malloc((aligned_height + 2) * img->bytes_per_line); D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy)); #endif - screen_base = (uint32)the_buffer; + screen_base = Host2MacAddr(the_buffer); // Create GC the_gc = XCreateGC(x_display, the_win, 0, 0); @@ -633,7 +633,7 @@ static bool open_dga(int width, int height) // Set frame buffer base D(bug("the_buffer = %p, use_vosf = %d\n", the_buffer, use_vosf)); - screen_base = (uint32)the_buffer; + screen_base = Host2MacAddr(the_buffer); VModes[cur_mode].viRowBytes = bytes_per_row; return true; #else @@ -1267,7 +1267,7 @@ static void suspend_emul(void) // Save frame buffer fb_save = malloc(VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes); if (fb_save) - memcpy(fb_save, (void *)screen_base, VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes); + Mac2Host_memcpy(fb_save, screen_base, VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes); // Close full screen display #ifdef ENABLE_XF86_DGA @@ -1329,7 +1329,7 @@ static void resume_emul(void) // Don't copy fb_save to the temporary frame buffer in VOSF mode if (!use_vosf) #endif - memcpy((void *)screen_base, fb_save, VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes); + Host2Mac_memcpy(screen_base, fb_save, VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes); free(fb_save); fb_save = NULL; } diff --git a/SheepShaver/src/emul_op.cpp b/SheepShaver/src/emul_op.cpp index c31805e4..0d05f52d 100644 --- a/SheepShaver/src/emul_op.cpp +++ b/SheepShaver/src/emul_op.cpp @@ -59,7 +59,7 @@ // TVector of MakeExecutable -static uint32 *MakeExecutableTvec; +static uint32 MakeExecutableTvec; /* @@ -259,11 +259,11 @@ void EmulOp(M68kRegisters *r, uint32 pc, int selector) InstallDrivers(); // Patch MakeExecutable() - MakeExecutableTvec = (uint32 *)FindLibSymbol("\023PrivateInterfaceLib", "\016MakeExecutable"); - D(bug("MakeExecutable TVECT at %p\n", MakeExecutableTvec)); - MakeExecutableTvec[0] = htonl(NativeFunction(NATIVE_MAKE_EXECUTABLE)); + MakeExecutableTvec = (uint32)FindLibSymbol("\023PrivateInterfaceLib", "\016MakeExecutable"); + D(bug("MakeExecutable TVECT at %08x\n", MakeExecutableTvec)); + WriteMacInt32(MakeExecutableTvec, NativeFunction(NATIVE_MAKE_EXECUTABLE)); #if !EMULATED_PPC - MakeExecutableTvec[1] = (uint32)TOC; + WriteMacInt32(MakeExecutableTvec + 4, (uint32)TOC); #endif // Patch DebugStr() @@ -272,7 +272,7 @@ void EmulOp(M68kRegisters *r, uint32 pc, int selector) PW(0x4e74), // rtd #4 PW(0x0004) }; - WriteMacInt32(0x1dfc, (uint32)proc); + WriteMacInt32(0x1dfc, Host2MacAddr((uint8 *)proc)); break; } @@ -297,7 +297,7 @@ void EmulOp(M68kRegisters *r, uint32 pc, int selector) WriteMacInt32(KernelDataAddr + 0x1b04, DR_CACHE_BASE); WriteMacInt32(KernelDataAddr + 0x1b00, DR_EMULATOR_BASE); memcpy((void *)DR_EMULATOR_BASE, (void *)(ROM_BASE + 0x370000), DR_EMULATOR_SIZE); - MakeExecutable(0, (void *)DR_EMULATOR_BASE, DR_EMULATOR_SIZE); + MakeExecutable(0, DR_EMULATOR_BASE, DR_EMULATOR_SIZE); } break; diff --git a/SheepShaver/src/gfxaccel.cpp b/SheepShaver/src/gfxaccel.cpp index 4320d4fc..4a367319 100644 --- a/SheepShaver/src/gfxaccel.cpp +++ b/SheepShaver/src/gfxaccel.cpp @@ -413,13 +413,13 @@ void VideoInstallAccel(void) WriteMacInt32(base + 0, NativeTVECT(NATIVE_BITBLT_HOOK)); WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK)); WriteMacInt32(base + 8, ACCL_BITBLT); - NQDMisc(6, bitblt_hook_info.ptr()); + NQDMisc(6, bitblt_hook_info.addr()); SheepVar fillrect_hook_info(sizeof(accl_hook_info)); base = fillrect_hook_info.addr(); WriteMacInt32(base + 0, NativeTVECT(NATIVE_FILLRECT_HOOK)); WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK)); WriteMacInt32(base + 8, ACCL_FILLRECT); - NQDMisc(6, fillrect_hook_info.ptr()); + NQDMisc(6, fillrect_hook_info.addr()); } } diff --git a/SheepShaver/src/include/cpu_emulation.h b/SheepShaver/src/include/cpu_emulation.h index a155f393..dd34bfa1 100644 --- a/SheepShaver/src/include/cpu_emulation.h +++ b/SheepShaver/src/include/cpu_emulation.h @@ -54,6 +54,8 @@ struct KernelData { // RAM and ROM pointers (allocated and set by main_*.cpp) extern uint32 RAMBase; // Base address of Mac RAM extern uint32 RAMSize; // Size address of Mac RAM +extern uint8 *RAMBaseHost; // Base address of Mac RAM (host address space) +extern uint8 *ROMBaseHost; // Base address of Mac ROM (host address space) // Mac memory access functions #if EMULATED_PPC diff --git a/SheepShaver/src/include/main.h b/SheepShaver/src/include/main.h index fb8248f1..234e3c4e 100644 --- a/SheepShaver/src/include/main.h +++ b/SheepShaver/src/include/main.h @@ -43,7 +43,7 @@ struct M68kRegisters { // Functions extern void Dump68kRegs(M68kRegisters *r); // Dump 68k registers -extern void MakeExecutable(int dummy, void *start, uint32 length); // Make code executable +extern void MakeExecutable(int dummy, uint32 start, uint32 length); // Make code executable extern void PatchAfterStartup(void); // Patches after system startup extern void QuitEmulator(void); // Quit emulator (must only be called from main thread) extern void ErrorAlert(const char *text); // Display error alert diff --git a/SheepShaver/src/include/thunks.h b/SheepShaver/src/include/thunks.h index 445e1cae..1c23b792 100644 --- a/SheepShaver/src/include/thunks.h +++ b/SheepShaver/src/include/thunks.h @@ -99,8 +99,8 @@ public: static bool Init(void); static void Exit(void); static uint32 PageSize(); - static uintptr ZeroPage(); - static uintptr Reserve(uint32 size); + static uint32 ZeroPage(); + static uint32 Reserve(uint32 size); static void Release(uint32 size); friend class SheepVar; }; @@ -116,12 +116,12 @@ inline uint32 SheepMem::PageSize() return page_size; } -inline uintptr SheepMem::ZeroPage() +inline uint32 SheepMem::ZeroPage() { return zero_page; } -inline uintptr SheepMem::Reserve(uint32 size) +inline uint32 SheepMem::Reserve(uint32 size) { top -= align(size); assert(top >= base); @@ -135,13 +135,12 @@ inline void SheepMem::Release(uint32 size) class SheepVar { - uintptr m_base; - uint32 m_size; + uint32 m_base; + uint32 m_size; public: SheepVar(uint32 requested_size); ~SheepVar() { SheepMem::Release(m_size); } - uintptr addr() const { return m_base; } - void *ptr() const { return (void *)addr(); } + uint32 addr() const { return m_base; } }; inline SheepVar::SheepVar(uint32 requested_size) @@ -152,11 +151,10 @@ inline SheepVar::SheepVar(uint32 requested_size) // TODO: optimize for 32-bit platforms -template< int size > +template< int requested_size > struct SheepArray : public SheepVar { - SheepArray() : SheepVar(size) { } - uint8 *ptr() const { return (uint8 *)addr(); } + SheepArray() : SheepVar(requested_size) { } }; struct SheepVar32 : public SheepVar @@ -165,17 +163,14 @@ struct SheepVar32 : public SheepVar SheepVar32(uint32 value) : SheepVar(4) { set_value(value); } uint32 value() const { return ReadMacInt32(addr()); } void set_value(uint32 v) { WriteMacInt32(addr(), v); } - uint32 *ptr() const { return (uint32 *)addr(); } }; struct SheepString : public SheepVar { SheepString(const char *str) : SheepVar(strlen(str) + 1) - { if (str) strcpy((char *)addr(), str); else WriteMacInt8(addr(), 0); } + { if (str) strcpy(value(), str); else WriteMacInt8(addr(), 0); } char *value() const - { return (char *)addr(); } - char *ptr() const - { return (char *)addr(); } + { return (char *)Mac2HostAddr(addr()); } }; #endif diff --git a/SheepShaver/src/include/video.h b/SheepShaver/src/include/video.h index c1257287..f45fea1d 100644 --- a/SheepShaver/src/include/video.h +++ b/SheepShaver/src/include/video.h @@ -24,7 +24,7 @@ extern bool VideoActivated(void); extern bool VideoSnapshot(int xsize, int ysize, uint8 *p); -extern int16 VideoDoDriverIO(void *spaceID, void *commandID, void *commandContents, uint32 commandCode, uint32 commandKind); +extern int16 VideoDoDriverIO(uint32 spaceID, uint32 commandID, uint32 commandContents, uint32 commandCode, uint32 commandKind); // System specific and internal functions/data struct VideoInfo { @@ -142,7 +142,7 @@ extern bool video_can_change_cursor(void); extern int16 video_mode_change(VidLocals *csSave, uint32 ParamPtr); extern int16 VSLDoInterruptService(uint32 arg1); -extern void NQDMisc(uint32 arg1, void *arg2); +extern void NQDMisc(uint32 arg1, uintptr arg2); // Native QuickDraw acceleration callbacks extern bool NQD_sync_hook(uint32); diff --git a/SheepShaver/src/kpx_cpu/sheepshaver_glue.cpp b/SheepShaver/src/kpx_cpu/sheepshaver_glue.cpp index 321bdd84..63a1324b 100644 --- a/SheepShaver/src/kpx_cpu/sheepshaver_glue.cpp +++ b/SheepShaver/src/kpx_cpu/sheepshaver_glue.cpp @@ -106,7 +106,7 @@ const uint32 POWERPC_EXEC_RETURN = POWERPC_EMUL_OP | 1; #define INTERRUPTS_IN_NATIVE_MODE 1 // Pointer to Kernel Data -static KernelData * const kernel_data = (KernelData *)KERNEL_DATA_BASE; +static KernelData * kernel_data; // SIGSEGV handler sigsegv_return_t sigsegv_handler(sigsegv_address_t, sigsegv_address_t); @@ -812,7 +812,7 @@ sigsegv_return_t sigsegv_handler(sigsegv_address_t fault_address, sigsegv_addres const uintptr addr = (uintptr)fault_address; #if HAVE_SIGSEGV_SKIP_INSTRUCTION // Ignore writes to ROM - if ((addr - ROM_BASE) < ROM_SIZE) + if ((addr - (uintptr)ROMBaseHost) < ROM_SIZE) return SIGSEGV_RETURN_SKIP_INSTRUCTION; // Get program counter of target CPU @@ -872,6 +872,9 @@ sigsegv_return_t sigsegv_handler(sigsegv_address_t fault_address, sigsegv_addres void init_emul_ppc(void) { + // Get pointer to KernelData in host address space + kernel_data = (KernelData *)Mac2HostAddr(KERNEL_DATA_BASE); + // Initialize main CPU emulator ppc_cpu = new sheepshaver_cpu(); ppc_cpu->set_register(powerpc_registers::GPR(3), any_register((uint32)ROM_BASE + 0x30d000)); @@ -1050,7 +1053,7 @@ void sheepshaver_cpu::handle_interrupt(void) 0x4e, 0xd0, // jmp (a0) M68K_RTS >> 8, M68K_RTS & 0xff // @1 }; - Execute68k((uint32)proc, &r); + Execute68k(Host2MacAddr((uint8 *)proc), &r); WriteMacInt32(XLM_68K_R25, old_r25); // Restore interrupt level #else // Only update cursor @@ -1099,8 +1102,7 @@ void sheepshaver_cpu::execute_native_op(uint32 selector) VideoVBL(); break; case NATIVE_VIDEO_DO_DRIVER_IO: - gpr(3) = (int32)(int16)VideoDoDriverIO((void *)gpr(3), (void *)gpr(4), - (void *)gpr(5), gpr(6), gpr(7)); + gpr(3) = (int32)(int16)VideoDoDriverIO(gpr(3), gpr(4), gpr(5), gpr(6), gpr(7)); break; #ifdef WORDS_BIGENDIAN case NATIVE_ETHER_IRQ: @@ -1185,7 +1187,7 @@ void sheepshaver_cpu::execute_native_op(uint32 selector) break; } case NATIVE_MAKE_EXECUTABLE: - MakeExecutable(0, (void *)gpr(4), gpr(5)); + MakeExecutable(0, gpr(4), gpr(5)); break; case NATIVE_CHECK_LOAD_INVOC: check_load_invoc(gpr(3), gpr(4), gpr(5)); diff --git a/SheepShaver/src/kpx_cpu/src/cpu/vm.hpp b/SheepShaver/src/kpx_cpu/src/cpu/vm.hpp index 2e961359..effcb9ba 100644 --- a/SheepShaver/src/kpx_cpu/src/cpu/vm.hpp +++ b/SheepShaver/src/kpx_cpu/src/cpu/vm.hpp @@ -189,16 +189,25 @@ typedef uintptr vm_addr_t; #if REAL_ADDRESSING const uintptr VMBaseDiff = 0; +#elif DIRECT_ADDRESSING && defined(NATMEM_OFFSET) +const uintptr VMBaseDiff = NATMEM_OFFSET; +// Wrap address to 32-bit if we are not using 33-bit addressing space +#if defined(SHEEPSHAVER) && SIZEOF_VOID_P == 8 +#define vm_wrap_address(ADDR) (uintptr)(uint32)(ADDR) +#endif +#endif +#ifndef vm_wrap_address +#define vm_wrap_address(ADDR) (ADDR) #endif -#if REAL_ADDRESSING +#if REAL_ADDRESSING || DIRECT_ADDRESSING static inline uint8 * vm_do_get_real_address(vm_addr_t addr) { - return (uint8 *)VMBaseDiff + addr; + return (uint8 *)vm_wrap_address(VMBaseDiff + addr); } static inline vm_addr_t vm_do_get_virtual_address(uint8 *addr) { - return (uintptr)addr - VMBaseDiff; + return vm_wrap_address((uintptr)addr - VMBaseDiff); } static inline uint32 vm_read_memory_1(vm_addr_t addr) { diff --git a/SheepShaver/src/macos_util.cpp b/SheepShaver/src/macos_util.cpp index c08a1ae6..6d09beb2 100644 --- a/SheepShaver/src/macos_util.cpp +++ b/SheepShaver/src/macos_util.cpp @@ -42,15 +42,15 @@ static inline long CallUniversal(void *arg1, uint32 arg2) } typedef int16 (*gsl_ptr)(char *, uint32, uint32, uint32 *, void **, char *); static uint32 gsl_tvect = 0; -static inline int16 GetSharedLibrary(char *arg1, uint32 arg2, uint32 arg3, uint32 *arg4, void **arg5, char *arg6) +static inline int16 GetSharedLibrary(uintptr arg1, uint32 arg2, uint32 arg3, uintptr arg4, uintptr arg5, uintptr arg6) { - return (int16)CallMacOS6(gsl_ptr, gsl_tvect, arg1, arg2, arg3, arg4, arg5, arg6); + return (int16)CallMacOS6(gsl_ptr, gsl_tvect, (char *)arg1, arg2, arg3, (uint32 *)arg4, (void **)arg5, (char *)arg6); } typedef int16 (*fs_ptr)(uint32, char *, void **, uint32 *); static uint32 fs_tvect = 0; -static inline int16 FindSymbol(uint32 arg1, char *arg2, void **arg3, uint32 *arg4) +static inline int16 FindSymbol(uint32 arg1, uintptr arg2, uintptr arg3, uintptr arg4) { - return (int16)CallMacOS4(fs_ptr, fs_tvect, arg1, arg2, arg3, arg4); + return (int16)CallMacOS4(fs_ptr, fs_tvect, arg1, (char *)arg2, (void **)arg3, (uint32 **)arg4); } typedef int16 (*cc_ptr)(uint32 *); static uint32 cc_tvect = 0; @@ -198,7 +198,7 @@ void *FindLibSymbol(char *lib_str, char *sym_str) r.a[1] = conn_id.addr(); r.a[2] = main_addr.addr(); r.a[3] = err.addr(); - Execute68k((uint32)proc1, &r); + Execute68k(Host2MacAddr((uint8 *)proc1), &r); D(bug(" GetSharedLibrary: ret %d, connection ID %ld, main %p\n", (int16)r.d[0], conn_id.value(), main_addr.value())); if (r.d[0]) return NULL; @@ -219,7 +219,7 @@ void *FindLibSymbol(char *lib_str, char *sym_str) r.a[0] = sym.addr(); r.a[1] = sym_addr.addr(); r.a[2] = sym_class.addr(); - Execute68k((uint32)proc2, &r); + Execute68k(Host2MacAddr((uint8 *)proc2), &r); D(bug(" FindSymbol1: ret %d, sym_addr %p, sym_class %ld\n", (int16)r.d[0], sym_addr.value(), sym_class.value())); //!! CloseConnection()? if (r.d[0]) @@ -234,11 +234,11 @@ void *FindLibSymbol(char *lib_str, char *sym_str) return 0; } int16 res; - res = GetSharedLibrary(lib.value(), FOURCC('p','w','p','c'), 1, (uint32 *)conn_id.addr(), (void **)main_addr.addr(), (char *)err.addr()); + res = GetSharedLibrary(lib.addr(), FOURCC('p','w','p','c'), 1, conn_id.addr(), main_addr.addr(), err.addr()); D(bug(" GetSharedLibrary: ret %d, connection ID %ld, main %p\n", res, conn_id.value(), main_addr.value())); if (res) return NULL; - res = FindSymbol(conn_id.value(), sym.value(), (void **)sym_addr.addr(), (uint32 *)sym_class.addr()); + res = FindSymbol(conn_id.value(), sym.addr(), sym_addr.addr(), sym_class.addr()); D(bug(" FindSymbol: ret %d, sym_addr %p, sym_class %ld\n", res, sym_addr.value(), sym_class.value())); //!!?? CloseConnection(&conn_id); if (res) diff --git a/SheepShaver/src/name_registry.cpp b/SheepShaver/src/name_registry.cpp index 2830ad30..3c2ec3a2 100644 --- a/SheepShaver/src/name_registry.cpp +++ b/SheepShaver/src/name_registry.cpp @@ -35,17 +35,17 @@ // Function pointers typedef int16 (*rcec_ptr)(const RegEntryID *, const char *, RegEntryID *); static uint32 rcec_tvect = 0; -static inline int16 RegistryCStrEntryCreate(const RegEntryID *arg1, const char *arg2, RegEntryID *arg3) +static inline int16 RegistryCStrEntryCreate(uintptr arg1, const char *arg2, uint32 arg3) { - return (int16)CallMacOS3(rcec_ptr, rcec_tvect, arg1, arg2, arg3); + return (int16)CallMacOS3(rcec_ptr, rcec_tvect, (const RegEntryID *)arg1, Host2MacAddr((uint8 *)arg2), arg3); } typedef int16 (*rpc_ptr)(const RegEntryID *, const char *, const void *, uint32); static uint32 rpc_tvect = 0; -static inline int16 RegistryPropertyCreate(const RegEntryID *arg1, const char *arg2, const void *arg3, uint32 arg4) +static inline int16 RegistryPropertyCreate(uintptr arg1, const char *arg2, uintptr arg3, uint32 arg4) { - return (int16)CallMacOS4(rpc_ptr, rpc_tvect, arg1, arg2, arg3, arg4); + return (int16)CallMacOS4(rpc_ptr, rpc_tvect, (const RegEntryID *)arg1, Host2MacAddr((uint8 *)arg2), (const void *)arg3, arg4); } -#define RegistryPropertyCreateStr(e,n,s) RegistryPropertyCreate(e,n,s,strlen(s)+1) +#define RegistryPropertyCreateStr(e,n,s) RegistryPropertyCreate(e,n,Host2MacAddr((uint8 *)s),strlen(s)+1) // Video driver stub static const uint8 video_driver[] = { @@ -58,16 +58,12 @@ static const uint8 ethernet_driver[] = { }; // Helper for RegEntryID -struct SheepRegEntryID : public SheepArray { - RegEntryID *ptr() const { return (RegEntryID *)addr(); } -}; +typedef SheepArray SheepRegEntryID; // Helper for a pair struct SheepPair : public SheepArray<8> { SheepPair(uint32 base, uint32 size) : SheepArray<8>() { WriteMacInt32(addr(), base); WriteMacInt32(addr() + 4, size); } - uint32 *ptr() const - { return (uint32 *)addr(); } }; @@ -82,17 +78,17 @@ void DoPatchNameRegistry(void) // Create "device-tree" SheepRegEntryID device_tree; - if (!RegistryCStrEntryCreate(NULL, "Devices:device-tree", device_tree.ptr())) { + if (!RegistryCStrEntryCreate(0, "Devices:device-tree", device_tree.addr())) { u32.set_value(BusClockSpeed); - RegistryPropertyCreate(device_tree.ptr(), "clock-frequency", u32.ptr(), 4); - RegistryPropertyCreateStr(device_tree.ptr(), "model", "Power Macintosh"); + RegistryPropertyCreate(device_tree.addr(), "clock-frequency", u32.addr(), 4); + RegistryPropertyCreateStr(device_tree.addr(), "model", "Power Macintosh"); // Create "AAPL,ROM" SheepRegEntryID aapl_rom; - if (!RegistryCStrEntryCreate(device_tree.ptr(), "AAPL,ROM", aapl_rom.ptr())) { - RegistryPropertyCreateStr(aapl_rom.ptr(), "device_type", "rom"); + if (!RegistryCStrEntryCreate(device_tree.addr(), "AAPL,ROM", aapl_rom.addr())) { + RegistryPropertyCreateStr(aapl_rom.addr(), "device_type", "rom"); SheepPair reg(ROM_BASE, ROM_SIZE); - RegistryPropertyCreate(aapl_rom.ptr(), "reg", reg.ptr(), 8); + RegistryPropertyCreate(aapl_rom.addr(), "reg", reg.addr(), 8); } // Create "PowerPC,60x" @@ -133,127 +129,127 @@ void DoPatchNameRegistry(void) str = "PowerPC,???"; break; } - if (!RegistryCStrEntryCreate(device_tree.ptr(), str, power_pc.ptr())) { + if (!RegistryCStrEntryCreate(device_tree.addr(), str, power_pc.addr())) { u32.set_value(CPUClockSpeed); - RegistryPropertyCreate(power_pc.ptr(), "clock-frequency", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "clock-frequency", u32.addr(), 4); u32.set_value(BusClockSpeed); - RegistryPropertyCreate(power_pc.ptr(), "bus-frequency", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "bus-frequency", u32.addr(), 4); u32.set_value(TimebaseSpeed); - RegistryPropertyCreate(power_pc.ptr(), "timebase-frequency", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "timebase-frequency", u32.addr(), 4); u32.set_value(PVR); - RegistryPropertyCreate(power_pc.ptr(), "cpu-version", u32.ptr(), 4); - RegistryPropertyCreateStr(power_pc.ptr(), "device_type", "cpu"); + RegistryPropertyCreate(power_pc.addr(), "cpu-version", u32.addr(), 4); + RegistryPropertyCreateStr(power_pc.addr(), "device_type", "cpu"); switch (PVR >> 16) { case 1: // 601 u32.set_value(64); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4); u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4); u32.set_value(0x8000); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4); u32.set_value(64); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4); u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4); u32.set_value(0x8000); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4); u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4); u32.set_value(256); - RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4); break; case 3: // 603 u32.set_value(32); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4); u32.set_value(64); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4); u32.set_value(0x2000); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4); u32.set_value(32); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4); u32.set_value(64); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4); u32.set_value(0x2000); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4); u32.set_value(32); - RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4); u32.set_value(64); - RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4); break; case 4: // 604 u32.set_value(32); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4); u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4); u32.set_value(0x4000); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4); u32.set_value(32); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4); u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4); u32.set_value(0x4000); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4); u32.set_value(64); - RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4); u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4); break; case 6: // 603e case 7: // 603ev u32.set_value(32); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4); u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4); u32.set_value(0x4000); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4); u32.set_value(32); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4); u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4); u32.set_value(0x4000); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4); u32.set_value(32); - RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4); u32.set_value(64); - RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4); break; case 8: // 750, 750FX case 0x7000: u32.set_value(32); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4); u32.set_value(256); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4); u32.set_value(0x8000); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4); u32.set_value(32); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4); u32.set_value(256); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4); u32.set_value(0x8000); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4); u32.set_value(64); - RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4); u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4); break; case 9: // 604e case 10: // 604ev5 u32.set_value(32); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4); u32.set_value(256); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4); u32.set_value(0x8000); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4); u32.set_value(32); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4); u32.set_value(256); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4); u32.set_value(0x8000); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4); u32.set_value(64); - RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4); u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4); break; case 12: // 7400, 7410, 7450, 7455, 7457 case 0x800c: @@ -261,72 +257,72 @@ void DoPatchNameRegistry(void) case 0x8001: case 0x8002: u32.set_value(32); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4); u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4); u32.set_value(0x8000); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4); u32.set_value(32); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4); u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4); u32.set_value(0x8000); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4); u32.set_value(64); - RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4); u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4); break; case 0x39: // 970 u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-block-size", u32.addr(), 4); u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-sets", u32.addr(), 4); u32.set_value(0x8000); - RegistryPropertyCreate(power_pc.ptr(), "d-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "d-cache-size", u32.addr(), 4); u32.set_value(128); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-block-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-block-size", u32.addr(), 4); u32.set_value(512); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-sets", u32.addr(), 4); u32.set_value(0x10000); - RegistryPropertyCreate(power_pc.ptr(), "i-cache-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "i-cache-size", u32.addr(), 4); u32.set_value(256); - RegistryPropertyCreate(power_pc.ptr(), "tlb-sets", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-sets", u32.addr(), 4); u32.set_value(0x1000); - RegistryPropertyCreate(power_pc.ptr(), "tlb-size", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "tlb-size", u32.addr(), 4); break; default: break; } u32.set_value(32); - RegistryPropertyCreate(power_pc.ptr(), "reservation-granularity", u32.ptr(), 4); + RegistryPropertyCreate(power_pc.addr(), "reservation-granularity", u32.addr(), 4); SheepPair reg(0, 0); - RegistryPropertyCreate(power_pc.ptr(), "reg", reg.ptr(), 8); + RegistryPropertyCreate(power_pc.addr(), "reg", reg.addr(), 8); } // Create "memory" SheepRegEntryID memory; - if (!RegistryCStrEntryCreate(device_tree.ptr(), "memory", memory.ptr())) { + if (!RegistryCStrEntryCreate(device_tree.addr(), "memory", memory.addr())) { SheepPair reg(RAMBase, RAMSize); - RegistryPropertyCreateStr(memory.ptr(), "device_type", "memory"); - RegistryPropertyCreate(memory.ptr(), "reg", reg.ptr(), 8); + RegistryPropertyCreateStr(memory.addr(), "device_type", "memory"); + RegistryPropertyCreate(memory.addr(), "reg", reg.addr(), 8); } // Create "video" SheepRegEntryID video; - if (!RegistryCStrEntryCreate(device_tree.ptr(), "video", video.ptr())) { - RegistryPropertyCreateStr(video.ptr(), "AAPL,connector", "monitor"); - RegistryPropertyCreateStr(video.ptr(), "device_type", "display"); - RegistryPropertyCreate(video.ptr(), "driver,AAPL,MacOS,PowerPC", video_driver, sizeof(video_driver)); - RegistryPropertyCreateStr(video.ptr(), "model", "SheepShaver Video"); + if (!RegistryCStrEntryCreate(device_tree.addr(), "video", video.addr())) { + RegistryPropertyCreateStr(video.addr(), "AAPL,connector", "monitor"); + RegistryPropertyCreateStr(video.addr(), "device_type", "display"); + RegistryPropertyCreate(video.addr(), "driver,AAPL,MacOS,PowerPC", Host2MacAddr((uint8 *)video_driver), sizeof(video_driver)); + RegistryPropertyCreateStr(video.addr(), "model", "SheepShaver Video"); } // Create "ethernet" SheepRegEntryID ethernet; - if (!RegistryCStrEntryCreate(device_tree.ptr(), "ethernet", ethernet.ptr())) { - RegistryPropertyCreateStr(ethernet.ptr(), "AAPL,connector", "ethernet"); - RegistryPropertyCreateStr(ethernet.ptr(), "device_type", "network"); - RegistryPropertyCreate(ethernet.ptr(), "driver,AAPL,MacOS,PowerPC", ethernet_driver, sizeof(ethernet_driver)); + if (!RegistryCStrEntryCreate(device_tree.addr(), "ethernet", ethernet.addr())) { + RegistryPropertyCreateStr(ethernet.addr(), "AAPL,connector", "ethernet"); + RegistryPropertyCreateStr(ethernet.addr(), "device_type", "network"); + RegistryPropertyCreate(ethernet.addr(), "driver,AAPL,MacOS,PowerPC", Host2MacAddr((uint8 *)ethernet_driver), sizeof(ethernet_driver)); // local-mac-address // max-frame-size 2048 } diff --git a/SheepShaver/src/rom_patches.cpp b/SheepShaver/src/rom_patches.cpp index 9daf7ae5..1ad61fc0 100644 --- a/SheepShaver/src/rom_patches.cpp +++ b/SheepShaver/src/rom_patches.cpp @@ -148,7 +148,7 @@ bool DecodeROM(uint8 *data, uint32 size) { if (size == ROM_SIZE) { // Plain ROM image - memcpy((void *)ROM_BASE, data, ROM_SIZE); + memcpy(ROMBaseHost, data, ROM_SIZE); return true; } else if (strncmp((char *)data, "", 11) == 0) { @@ -186,12 +186,12 @@ bool DecodeROM(uint8 *data, uint32 size) if (rom_signature == FOURCC('p','r','c','l')) { D(bug("Offset of parcels data: %08x\n", image_offset)); D(bug("Size of parcels data: %08x\n", image_size)); - decode_parcels(data + image_offset, (uint8 *)ROM_BASE, image_size); + decode_parcels(data + image_offset, ROMBaseHost, image_size); } else { D(bug("Offset of compressed data: %08x\n", image_offset)); D(bug("Size of compressed data: %08x\n", image_size)); - decode_lzss(data + image_offset, (uint8 *)ROM_BASE, image_size); + decode_lzss(data + image_offset, ROMBaseHost, image_size); } return true; } @@ -207,7 +207,7 @@ static uint32 find_rom_data(uint32 start, uint32 end, const uint8 *data, uint32 { uint32 ofs = start; while (ofs < end) { - if (!memcmp((void *)(ROM_BASE + ofs), data, data_len)) + if (!memcmp(ROMBaseHost + ofs, data, data_len)) return ofs; ofs++; } @@ -224,9 +224,9 @@ static uint32 rsrc_ptr = 0; // id = 4711 means "find any ID" static uint32 find_rom_resource(uint32 s_type, int16 s_id = 4711, bool cont = false) { - uint32 *lp = (uint32 *)(ROM_BASE + 0x1a); + uint32 *lp = (uint32 *)(ROMBaseHost + 0x1a); uint32 x = ntohl(*lp); - uint8 *bp = (uint8 *)(ROM_BASE + x + 5); + uint8 *bp = (uint8 *)(ROMBaseHost + x + 5); uint32 header_size = *bp; if (!cont) @@ -235,14 +235,14 @@ static uint32 find_rom_resource(uint32 s_type, int16 s_id = 4711, bool cont = fa return 0; for (;;) { - lp = (uint32 *)(ROM_BASE + rsrc_ptr); + lp = (uint32 *)(ROMBaseHost + rsrc_ptr); rsrc_ptr = ntohl(*lp); if (rsrc_ptr == 0) break; rsrc_ptr += header_size; - lp = (uint32 *)(ROM_BASE + rsrc_ptr + 4); + lp = (uint32 *)(ROMBaseHost + rsrc_ptr + 4); uint32 data = ntohl(*lp); lp++; uint32 type = ntohl(*lp); lp++; int16 id = ntohs(*(int16 *)lp); @@ -259,8 +259,8 @@ static uint32 find_rom_resource(uint32 s_type, int16 s_id = 4711, bool cont = fa static uint32 find_rom_trap(uint16 trap) { - uint32 *lp = (uint32 *)(ROM_BASE + 0x22); - lp = (uint32 *)(ROM_BASE + ntohl(*lp)); + uint32 *lp = (uint32 *)(ROMBaseHost + 0x22); + lp = (uint32 *)(ROMBaseHost + ntohl(*lp)); if (trap > 0xa800) return ntohl(lp[trap & 0x3ff]); @@ -274,9 +274,9 @@ static uint32 find_rom_trap(uint16 trap) * there is no such instruction */ -static uint32 powerpc_branch_target(uintptr addr) +static uint32 rom_powerpc_branch_target(uint32 addr) { - uint32 opcode = ntohl(*(uint32 *)addr); + uint32 opcode = ntohl(*(uint32 *)(ROMBaseHost + addr)); uint32 primop = opcode >> 26; uint32 target = 0; @@ -303,7 +303,7 @@ static uint32 powerpc_branch_target(uintptr addr) static uint32 find_rom_powerpc_branch(uint32 start, uint32 end, uint32 target) { for (uint32 addr = start; addr < end; addr += 4) { - if (powerpc_branch_target(ROM_BASE + addr) == ROM_BASE + target) + if (rom_powerpc_branch_target(addr) == target) return addr; } return 0; @@ -318,7 +318,7 @@ static bool check_rom_patch_space(uint32 base, uint32 size) { size = (size + 3) & -4; for (int i = 0; i < size; i += 4) { - uint32 x = ntohl(*(uint32 *)(ROM_BASE + base + i)); + uint32 x = ntohl(*(uint32 *)(ROMBaseHost + base + i)); if (x != 0x6b636b63 && x != 0) return false; } @@ -689,25 +689,25 @@ static inline void memcpy_powerpc_code(void *dst, const void *src, size_t len) bool PatchROM(void) { // Print ROM info - D(bug("Checksum: %08lx\n", ntohl(*(uint32 *)ROM_BASE))); - D(bug("Version: %04x\n", ntohs(*(uint16 *)(ROM_BASE + 8)))); - D(bug("Sub Version: %04x\n", ntohs(*(uint16 *)(ROM_BASE + 18)))); - D(bug("Nanokernel ID: %s\n", (char *)ROM_BASE + 0x30d064)); - D(bug("Resource Map at %08lx\n", ntohl(*(uint32 *)(ROM_BASE + 26)))); - D(bug("Trap Tables at %08lx\n\n", ntohl(*(uint32 *)(ROM_BASE + 34)))); + D(bug("Checksum: %08lx\n", ntohl(*(uint32 *)ROMBaseHost))); + D(bug("Version: %04x\n", ntohs(*(uint16 *)(ROMBaseHost + 8)))); + D(bug("Sub Version: %04x\n", ntohs(*(uint16 *)(ROMBaseHost + 18)))); + D(bug("Nanokernel ID: %s\n", (char *)ROMBaseHost + 0x30d064)); + D(bug("Resource Map at %08lx\n", ntohl(*(uint32 *)(ROMBaseHost + 26)))); + D(bug("Trap Tables at %08lx\n\n", ntohl(*(uint32 *)(ROMBaseHost + 34)))); // Detect ROM type - if (!memcmp((void *)(ROM_BASE + 0x30d064), "Boot TNT", 8)) + if (!memcmp(ROMBaseHost + 0x30d064, "Boot TNT", 8)) ROMType = ROMTYPE_TNT; - else if (!memcmp((void *)(ROM_BASE + 0x30d064), "Boot Alchemy", 12)) + else if (!memcmp(ROMBaseHost + 0x30d064, "Boot Alchemy", 12)) ROMType = ROMTYPE_ALCHEMY; - else if (!memcmp((void *)(ROM_BASE + 0x30d064), "Boot Zanzibar", 13)) + else if (!memcmp(ROMBaseHost + 0x30d064, "Boot Zanzibar", 13)) ROMType = ROMTYPE_ZANZIBAR; - else if (!memcmp((void *)(ROM_BASE + 0x30d064), "Boot Gazelle", 12)) + else if (!memcmp(ROMBaseHost + 0x30d064, "Boot Gazelle", 12)) ROMType = ROMTYPE_GAZELLE; - else if (!memcmp((void *)(ROM_BASE + 0x30d064), "Boot Gossamer", 13)) + else if (!memcmp(ROMBaseHost + 0x30d064, "Boot Gossamer", 13)) ROMType = ROMTYPE_GOSSAMER; - else if (!memcmp((void *)(ROM_BASE + 0x30d064), "NewWorld", 8)) + else if (!memcmp(ROMBaseHost + 0x30d064, "NewWorld", 8)) ROMType = ROMTYPE_NEWWORLD; else return false; @@ -730,19 +730,19 @@ bool PatchROM(void) #ifdef M68K_BREAK_POINT // Install 68k breakpoint - uint16 *wp = (uint16 *)(ROM_BASE + M68K_BREAK_POINT); + uint16 *wp = (uint16 *)(ROMBaseHost + M68K_BREAK_POINT); *wp++ = htons(M68K_EMUL_BREAK); *wp = htons(M68K_EMUL_RETURN); #endif #ifdef POWERPC_BREAK_POINT // Install PowerPC breakpoint - uint32 *lp = (uint32 *)(ROM_BASE + POWERPC_BREAK_POINT); + uint32 *lp = (uint32 *)(ROMBaseHost + POWERPC_BREAK_POINT); *lp = htonl(0); #endif // Copy 68k emulator to 2MB boundary - memcpy((void *)(ROM_BASE + ROM_SIZE), (void *)(ROM_BASE + ROM_SIZE - 0x100000), 0x100000); + memcpy(ROMBaseHost + ROM_SIZE, ROMBaseHost + (ROM_SIZE - 0x100000), 0x100000); return true; } @@ -757,7 +757,7 @@ static bool patch_nanokernel_boot(void) uint32 base, loc; // ROM boot structure patches - lp = (uint32 *)(ROM_BASE + 0x30d000); + lp = (uint32 *)(ROMBaseHost + 0x30d000); lp[0x9c >> 2] = htonl(KernelDataAddr); // LA_InfoRecord lp[0xa0 >> 2] = htonl(KernelDataAddr); // LA_KernelData lp[0xa4 >> 2] = htonl(KernelDataAddr + 0x1000); // LA_EmulatorData @@ -769,16 +769,16 @@ static bool patch_nanokernel_boot(void) // Skip SR/BAT/SDR init loc = 0x310000; if (ROMType == ROMTYPE_GAZELLE || ROMType == ROMTYPE_GOSSAMER || ROMType == ROMTYPE_NEWWORLD) { - lp = (uint32 *)(ROM_BASE + loc); + lp = (uint32 *)(ROMBaseHost + loc); *lp++ = htonl(POWERPC_NOP); *lp = htonl(0x38000000); } static const uint8 sr_init_dat[] = {0x35, 0x4a, 0xff, 0xfc, 0x7d, 0x86, 0x50, 0x2e}; if ((base = find_rom_data(0x3101b0, 0x3105b0, sr_init_dat, sizeof(sr_init_dat))) == 0) return false; D(bug("sr_init %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + loc + 8); + lp = (uint32 *)(ROMBaseHost + loc + 8); *lp = htonl(0x48000000 | ((base - loc - 8) & 0x3fffffc)); // b ROM_BASE+0x3101b0 - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp++ = htonl(0x80200000 + XLM_KERNEL_DATA); // lwz r1,(pointer to Kernel Data) *lp++ = htonl(0x3da0dead); // lis r13,0xdead (start of kernel memory) *lp++ = htonl(0x3dc00010); // lis r14,0x0010 (size of page table) @@ -788,7 +788,7 @@ static bool patch_nanokernel_boot(void) static const uint8 pvr_read_dat[] = {0x7d, 0x9f, 0x42, 0xa6}; if ((base = find_rom_data(0x3103b0, 0x3108b0, pvr_read_dat, sizeof(pvr_read_dat))) == 0) return false; D(bug("pvr_read %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp = htonl(0x81800000 + XLM_PVR); // lwz r12,(theoretical PVR) // Set CPU specific data (even if ROM doesn't have support for that CPU) @@ -797,9 +797,9 @@ static bool patch_nanokernel_boot(void) uint32 ofs = ntohl(lp[7]) & 0xffff; D(bug("ofs %08lx\n", ofs)); lp[8] = htonl((ntohl(lp[8]) & 0xffff) | 0x48000000); // beq -> b - loc = (ntohl(lp[8]) & 0xffff) + (uint32)(lp+8) - ROM_BASE; + loc = (ntohl(lp[8]) & 0xffff) + (uintptr)(lp+8) - (uintptr)ROMBaseHost; D(bug("loc %08lx\n", loc)); - lp = (uint32 *)(ROM_BASE + ofs + 0x310000); + lp = (uint32 *)(ROMBaseHost + ofs + 0x310000); switch (PVR >> 16) { case 1: // 601 lp[0] = htonl(0x1000); // Page size @@ -931,7 +931,7 @@ static bool patch_nanokernel_boot(void) static const uint8 sprg3_mq_dat[] = {0x7d, 0x13, 0x43, 0xa6, 0x3d, 0x00, 0x00, 0x04, 0x7d, 0x00, 0x03, 0xa6, 0x39, 0x00, 0x00, 0x00, 0x7d, 0x00, 0x02, 0xa6}; if ((base = find_rom_data(loc + 0x20, loc + 0x60, sprg3_mq_dat, sizeof(sprg3_mq_dat))) == 0) return false; D(bug("sprg3/mq %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); lp[0] = htonl(POWERPC_NOP); lp[2] = htonl(POWERPC_NOP); lp[4] = htonl(POWERPC_NOP); @@ -940,43 +940,43 @@ static bool patch_nanokernel_boot(void) static const uint8 msr_dat[] = {0x7d, 0xc0, 0x00, 0xa6}; if ((base = find_rom_data(loc + 0x40, loc + 0x80, msr_dat, sizeof(msr_dat))) == 0) return false; D(bug("msr %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp = htonl(0x39c00000); // li r14,0 // Don't write to DEC - lp = (uint32 *)(ROM_BASE + loc + 0x70); + lp = (uint32 *)(ROMBaseHost + loc + 0x70); *lp++ = htonl(POWERPC_NOP); - loc = (ntohl(lp[0]) & 0xffff) + (uint32)lp - ROM_BASE; + loc = (ntohl(lp[0]) & 0xffff) + (uintptr)lp - (uintptr)ROMBaseHost; D(bug("loc %08lx\n", loc)); // Don't set SPRG3 static const uint8 sprg3_dat[] = {0x39, 0x21, 0x03, 0x60, 0x7d, 0x33, 0x43, 0xa6, 0x39, 0x01, 0x04, 0x20}; if ((base = find_rom_data(0x310000, 0x314000, sprg3_dat, sizeof(sprg3_dat))) == 0) return false; D(bug("sprg3 %08lx\n", base + 4)); - lp = (uint32 *)(ROM_BASE + base + 4); + lp = (uint32 *)(ROMBaseHost + base + 4); *lp = htonl(POWERPC_NOP); // Don't read PVR static const uint8 pvr_read2_dat[] = {0x7e, 0xff, 0x42, 0xa6, 0x56, 0xf7, 0x84, 0x3e}; if ((base = find_rom_data(0x310000, 0x320000, pvr_read2_dat, sizeof(pvr_read2_dat))) == 0) return false; D(bug("pvr_read2 %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp = htonl(0x82e00000 + XLM_PVR); // lwz r23,(theoretical PVR) if ((base = find_rom_data(base + 4, 0x320000, pvr_read2_dat, sizeof(pvr_read2_dat))) != 0) { D(bug("pvr_read2 %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp = htonl(0x82e00000 + XLM_PVR); // lwz r23,(theoretical PVR) } static const uint8 pvr_read3_dat[] = {0x7e, 0x5f, 0x42, 0xa6, 0x56, 0x52, 0x84, 0x3e}; if ((base = find_rom_data(0x310000, 0x320000, pvr_read3_dat, sizeof(pvr_read3_dat))) != 0) { D(bug("pvr_read3 %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp = htonl(0x82400000 + XLM_PVR); // lwz r18,(theoretical PVR) } static const uint8 pvr_read4_dat[] = {0x7d, 0x3f, 0x42, 0xa6, 0x55, 0x29, 0x84, 0x3e}; if ((base = find_rom_data(0x310000, 0x320000, pvr_read4_dat, sizeof(pvr_read4_dat))) != 0) { D(bug("pvr_read4 %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp = htonl(0x81200000 + XLM_PVR); // lzw r9,(theoritical PVR) } @@ -984,7 +984,7 @@ static bool patch_nanokernel_boot(void) static const uint8 sdr1_read_dat[] = {0x7d, 0x19, 0x02, 0xa6, 0x55, 0x16, 0x81, 0xde}; if ((base = find_rom_data(0x310000, 0x320000, sdr1_read_dat, sizeof(sdr1_read_dat))) == 0) return false; D(bug("sdr1_read %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp++ = htonl(0x3d00dead); // lis r8,0xdead (pointer to page table) *lp++ = htonl(0x3ec0001f); // lis r22,0x001f (size of page table) *lp = htonl(POWERPC_NOP); @@ -993,17 +993,17 @@ static bool patch_nanokernel_boot(void) static const uint8 pgtb_clear_dat[] = {0x36, 0xd6, 0xff, 0xfc, 0x7e, 0xe8, 0xb1, 0x2e, 0x41, 0x81, 0xff, 0xf8}; if ((base = find_rom_data(0x310000, 0x320000, pgtb_clear_dat, sizeof(pgtb_clear_dat))) == 0) return false; D(bug("pgtb_clear %08lx\n", base + 4)); - lp = (uint32 *)(ROM_BASE + base + 4); + lp = (uint32 *)(ROMBaseHost + base + 4); *lp = htonl(POWERPC_NOP); D(bug("tblie %08lx\n", base + 12)); - lp = (uint32 *)(ROM_BASE + base + 12); + lp = (uint32 *)(ROMBaseHost + base + 12); *lp = htonl(POWERPC_NOP); // Don't create RAM descriptor table static const uint8 desc_create_dat[] = {0x97, 0xfd, 0x00, 0x04, 0x3b, 0xff, 0x10, 0x00, 0x4b, 0xff, 0xff, 0xdc}; if ((base = find_rom_data(0x310000, 0x320000, desc_create_dat, sizeof(desc_create_dat))) == 0) return false; D(bug("desc_create %08lx\n", base)) - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp = htonl(POWERPC_NOP); // Don't load SRs and BATs @@ -1013,21 +1013,21 @@ static bool patch_nanokernel_boot(void) if ((base = find_rom_data(0x310000, 0x320000, sr_load_caller, sizeof(sr_load_caller))) == 0) return false; if ((base = find_rom_powerpc_branch(base + 12, 0x320000, loc)) == 0) return false; D(bug("sr_load %08lx, called from %08lx\n", loc, base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp = htonl(POWERPC_NOP); // Don't mess with SRs static const uint8 sr_load2_dat[] = {0x83, 0xa1, 0x05, 0xe8, 0x57, 0x7c, 0x3e, 0x78, 0x7f, 0xbd, 0xe0, 0x2e}; if ((base = find_rom_data(0x310000, 0x320000, sr_load2_dat, sizeof(sr_load2_dat))) == 0) return false; D(bug("sr_load2 %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp = htonl(POWERPC_BLR); // Don't check performance monitor static const uint8 pm_check_dat[] = {0x7e, 0x58, 0xeb, 0xa6, 0x7e, 0x53, 0x90, 0xf8, 0x7e, 0x78, 0xea, 0xa6}; if ((base = find_rom_data(0x310000, 0x320000, pm_check_dat, sizeof(pm_check_dat))) == 0) return false; D(bug("pm_check %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); static const int spr_check_list[] = { 952 /* mmcr0 */, 953 /* pmc1 */, 954 /* pmc2 */, 955 /* sia */, @@ -1056,7 +1056,7 @@ static bool patch_nanokernel_boot(void) if ((base = find_rom_data(0x310000, 0x320000, jump68k_caller_dat, sizeof(jump68k_caller_dat))) == 0) return false; if ((base = find_rom_powerpc_branch(base + 12, 0x320000, loc)) == 0) return false; D(bug("jump68k %08lx, called from %08lx\n", loc, base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp++ = htonl(0x80610634); // lwz r3,0x0634(r1) (pointer to Emulator Data) *lp++ = htonl(0x8081119c); // lwz r4,0x119c(r1) (pointer to opcode table) *lp++ = htonl(0x80011184); // lwz r0,0x1184(r1) (pointer to emulator init routine) @@ -1079,7 +1079,7 @@ static bool patch_68k_emul(void) static const uint8 twi_dat[] = {0x0f, 0xff, 0x00, 0x00, 0x0f, 0xff, 0x00, 0x01, 0x0f, 0xff, 0x00, 0x02}; if ((base = find_rom_data(0x36e600, 0x36ea00, twi_dat, sizeof(twi_dat))) == 0) return false; D(bug("twi %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp++ = htonl(0x48000000 + 0x36f900 - base); // b 0x36f900 (Emulator start) *lp++ = htonl(0x48000000 + 0x36fa00 - base - 4); // b 0x36fa00 (Mixed mode) *lp++ = htonl(0x48000000 + 0x36fb00 - base - 8); // b 0x36fb00 (Reset/FC1E opcode) @@ -1099,7 +1099,7 @@ static bool patch_68k_emul(void) #if EMULATED_PPC // Install EMUL_RETURN, EXEC_RETURN, EXEC_NATIVE and EMUL_OP opcodes - lp = (uint32 *)(ROM_BASE + 0x380000 + (M68K_EMUL_RETURN << 3)); + lp = (uint32 *)(ROMBaseHost + 0x380000 + (M68K_EMUL_RETURN << 3)); *lp++ = htonl(POWERPC_EMUL_OP); *lp++ = htonl(0x4bf66e80); // b 0x366084 *lp++ = htonl(POWERPC_EMUL_OP | 1); @@ -1112,7 +1112,7 @@ static bool patch_68k_emul(void) } #else // Install EMUL_RETURN, EXEC_RETURN and EMUL_OP opcodes - lp = (uint32 *)(ROM_BASE + 0x380000 + (M68K_EMUL_RETURN << 3)); + lp = (uint32 *)(ROMBaseHost + 0x380000 + (M68K_EMUL_RETURN << 3)); *lp++ = htonl(0x80000000 + XLM_EMUL_RETURN_PROC); // lwz r0,XLM_EMUL_RETURN_PROC *lp++ = htonl(0x4bf705fc); // b 0x36f800 *lp++ = htonl(0x80000000 + XLM_EXEC_RETURN_PROC); // lwz r0,XLM_EXEC_RETURN_PROC @@ -1125,7 +1125,7 @@ static bool patch_68k_emul(void) } // Extra routines for EMUL_RETURN/EXEC_RETURN/EMUL_OP - lp = (uint32 *)(ROM_BASE + 0x36f800); + lp = (uint32 *)(ROMBaseHost + 0x36f800); *lp++ = htonl(0x7c0803a6); // mtlr r0 *lp++ = htonl(0x4e800020); // blr @@ -1135,7 +1135,7 @@ static bool patch_68k_emul(void) #endif // Extra routine for 68k emulator start - lp = (uint32 *)(ROM_BASE + 0x36f900); + lp = (uint32 *)(ROMBaseHost + 0x36f900); *lp++ = htonl(0x7c2903a6); // mtctr r1 *lp++ = htonl(0x80200000 + XLM_IRQ_NEST); // lwz r1,XLM_IRQ_NEST *lp++ = htonl(0x38210001); // addi r1,r1,1 @@ -1165,7 +1165,7 @@ static bool patch_68k_emul(void) *lp = htonl(0x4e800020); // blr // Extra routine for Mixed Mode - lp = (uint32 *)(ROM_BASE + 0x36fa00); + lp = (uint32 *)(ROMBaseHost + 0x36fa00); *lp++ = htonl(0x7c2903a6); // mtctr r1 *lp++ = htonl(0x80200000 + XLM_IRQ_NEST); // lwz r1,XLM_IRQ_NEST *lp++ = htonl(0x38210001); // addi r1,r1,1 @@ -1195,7 +1195,7 @@ static bool patch_68k_emul(void) *lp = htonl(0x4e800020); // blr // Extra routine for Reset/FC1E opcode - lp = (uint32 *)(ROM_BASE + 0x36fb00); + lp = (uint32 *)(ROMBaseHost + 0x36fb00); *lp++ = htonl(0x7c2903a6); // mtctr r1 *lp++ = htonl(0x80200000 + XLM_IRQ_NEST); // lwz r1,XLM_IRQ_NEST *lp++ = htonl(0x38210001); // addi r1,r1,1 @@ -1225,7 +1225,7 @@ static bool patch_68k_emul(void) *lp = htonl(0x4e800020); // blr // Extra routine for FE0A opcode (QuickDraw 3D needs this) - lp = (uint32 *)(ROM_BASE + 0x36fc00); + lp = (uint32 *)(ROMBaseHost + 0x36fc00); *lp++ = htonl(0x7c2903a6); // mtctr r1 *lp++ = htonl(0x80200000 + XLM_IRQ_NEST); // lwz r1,XLM_IRQ_NEST *lp++ = htonl(0x38210001); // addi r1,r1,1 @@ -1255,8 +1255,8 @@ static bool patch_68k_emul(void) *lp = htonl(0x4e800020); // blr // Patch DR emulator to jump to right address when an interrupt occurs - lp = (uint32 *)(ROM_BASE + 0x370000); - while (lp < (uint32 *)(ROM_BASE + 0x380000)) { + lp = (uint32 *)(ROMBaseHost + 0x370000); + while (lp < (uint32 *)(ROMBaseHost + 0x380000)) { if (ntohl(*lp) == 0x4ca80020) // bclr 5,8 goto dr_found; lp++; @@ -1265,16 +1265,16 @@ static bool patch_68k_emul(void) return false; dr_found: lp++; - loc = (uint32)lp - ROM_BASE; - if ((base = powerpc_branch_target(ROM_BASE + loc)) == 0) base = ROM_BASE + loc; + loc = (uintptr)lp - (uintptr)ROMBaseHost; + if ((base = rom_powerpc_branch_target(loc)) == 0) base = ROM_BASE + loc; static const uint8 dr_ret_dat[] = {0x80, 0xbf, 0x08, 0x14, 0x53, 0x19, 0x4d, 0xac, 0x7c, 0xa8, 0x03, 0xa6}; if ((base = find_rom_data(base - ROM_BASE, 0x380000, dr_ret_dat, sizeof(dr_ret_dat))) == 0) return false; D(bug("dr_ret %08lx\n", base)); if (base != loc) { // OldWorld ROMs contain an absolute branch - D(bug(" patching absolute branch at %08x\n", (uint32)lp - ROM_BASE)); - *lp = htonl(0x48000000 + 0xf000 - (((uint32)lp - ROM_BASE) & 0xffff)); // b DR_CACHE_BASE+0x1f000 - lp = (uint32 *)(ROM_BASE + 0x37f000); + D(bug(" patching absolute branch at %08x\n", loc)); + *lp = htonl(0x48000000 + 0xf000 - (loc & 0xffff)); // b DR_CACHE_BASE+0x1f000 + lp = (uint32 *)(ROMBaseHost + 0x37f000); *lp++ = htonl(0x3c000000 + ((ROM_BASE + base) >> 16)); // lis r0,xxx *lp++ = htonl(0x60000000 + ((ROM_BASE + base) & 0xffff)); // ori r0,r0,xxx *lp++ = htonl(0x7c0803a6); // mtlr r0 @@ -1297,23 +1297,23 @@ static bool patch_nanokernel(void) static const uint8 virt2phys_dat[] = {0x7d, 0x1b, 0x43, 0x78, 0x3b, 0xa1, 0x03, 0x20}; if ((base = find_rom_data(0x313000, 0x314000, virt2phys_dat, sizeof(virt2phys_dat))) == 0) return false; D(bug("virt2phys %08lx\n", base + 8)); - lp = (uint32 *)(ROM_BASE + base + 8); // Don't translate virtual->physical + lp = (uint32 *)(ROMBaseHost + base + 8); // Don't translate virtual->physical lp[0] = htonl(0x7f7fdb78); // mr r31,r27 lp[2] = htonl(POWERPC_NOP); static const uint8 ppc_excp_tbl_dat[] = {0x39, 0x01, 0x04, 0x20, 0x7d, 0x13, 0x43, 0xa6}; if ((base = find_rom_data(0x313000, 0x314000, ppc_excp_tbl_dat, sizeof(ppc_excp_tbl_dat))) == 0) return false; D(bug("ppc_excp_tbl %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); // Don't activate PPC exception table + lp = (uint32 *)(ROMBaseHost + base); // Don't activate PPC exception table *lp++ = htonl(0x39000000 + MODE_NATIVE); // li r8,MODE_NATIVE *lp = htonl(0x91000000 + XLM_RUN_MODE); // stw r8,XLM_RUN_MODE static const uint8 save_fpu_dat[] = {0x7d, 0x00, 0x00, 0xa6, 0x61, 0x08, 0x20, 0x00, 0x7d, 0x00, 0x01, 0x24}; if ((base = find_rom_data(0x310000, 0x314000, save_fpu_dat, sizeof(save_fpu_dat))) == 0) return false; D(bug("save_fpu %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); // Don't modify MSR to turn on FPU + lp = (uint32 *)(ROMBaseHost + base); // Don't modify MSR to turn on FPU if (ntohl(lp[4]) != 0x556b04e2) return false; - loc = ROM_BASE + base; + loc = base; #if 1 // FIXME: is that really intended? *lp++ = htonl(POWERPC_NOP); @@ -1331,14 +1331,14 @@ static bool patch_nanokernel(void) static const uint8 save_fpu_caller_dat[] = {0x93, 0xa6, 0x01, 0xec, 0x93, 0xc6, 0x01, 0xf4, 0x93, 0xe6, 0x01, 0xfc, 0x40}; if ((base = find_rom_data(0x310000, 0x314000, save_fpu_caller_dat, sizeof(save_fpu_caller_dat))) == 0) return false; D(bug("save_fpu_caller %08lx\n", base + 12)); - if (powerpc_branch_target(ROM_BASE + base + 12) != loc) return false; - lp = (uint32 *)(ROM_BASE + base + 12); // Always save FPU state + if (rom_powerpc_branch_target(base + 12) != loc) return false; + lp = (uint32 *)(ROMBaseHost + base + 12); // Always save FPU state *lp = htonl(0x48000000 | (ntohl(*lp) & 0xffff)); // bl 0x00312e88 static const uint8 mdec_dat[] = {0x7f, 0xf6, 0x02, 0xa6, 0x2c, 0x08, 0x00, 0x00, 0x93, 0xe1, 0x06, 0x68, 0x7d, 0x16, 0x03, 0xa6}; if ((base = find_rom_data(0x310000, 0x314000, mdec_dat, sizeof(mdec_dat))) == 0) return false; D(bug("mdec %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); // Don't modify DEC + lp = (uint32 *)(ROMBaseHost + base); // Don't modify DEC lp[0] = htonl(0x3be00000); // li r31,0 #if 1 lp[3] = htonl(POWERPC_NOP); @@ -1351,13 +1351,13 @@ static bool patch_nanokernel(void) static const uint8 restore_fpu_caller_dat[] = {0x81, 0x06, 0x00, 0xf4, 0x81, 0x46, 0x00, 0xfc, 0x7d, 0x09, 0x03, 0xa6, 0x40}; if ((base = find_rom_data(0x310000, 0x314000, restore_fpu_caller_dat, sizeof(restore_fpu_caller_dat))) == 0) return false; D(bug("restore_fpu_caller %08lx\n", base + 12)); - lp = (uint32 *)(ROM_BASE + base + 12); // Always restore FPU state + lp = (uint32 *)(ROMBaseHost + base + 12); // Always restore FPU state *lp = htonl(0x48000000 | (ntohl(*lp) & 0xffff)); // bl 0x00312ddc static const uint8 m68k_excp_tbl_dat[] = {0x81, 0x21, 0x06, 0x58, 0x39, 0x01, 0x03, 0x60, 0x7d, 0x13, 0x43, 0xa6}; if ((base = find_rom_data(0x310000, 0x314000, m68k_excp_tbl_dat, sizeof(m68k_excp_tbl_dat))) == 0) return false; D(bug("m68k_excp %08lx\n", base + 4)); - lp = (uint32 *)(ROM_BASE + base + 4); // Don't activate 68k exception table + lp = (uint32 *)(ROMBaseHost + base + 4); // Don't activate 68k exception table *lp++ = htonl(0x39000000 + MODE_68K); // li r8,MODE_68K *lp = htonl(0x91000000 + XLM_RUN_MODE); // stw r8,XLM_RUN_MODE @@ -1365,15 +1365,15 @@ static bool patch_nanokernel(void) static const uint8 restore_fpu_caller2_dat[] = {0x81, 0x86, 0x00, 0x8c, 0x80, 0x66, 0x00, 0x94, 0x80, 0x86, 0x00, 0x9c, 0x40}; if ((base = find_rom_data(0x310000, 0x314000, restore_fpu_caller2_dat, sizeof(restore_fpu_caller2_dat))) == 0) return false; D(bug("restore_fpu_caller2 %08lx\n", base + 12)); - loc = powerpc_branch_target(ROM_BASE + base + 12) - ROM_BASE; - lp = (uint32 *)(ROM_BASE + base + 12); // Always restore FPU state + loc = rom_powerpc_branch_target(base + 12); + lp = (uint32 *)(ROMBaseHost + base + 12); // Always restore FPU state *lp = htonl(0x48000000 | (ntohl(*lp) & 0xffff)); // bl 0x00312dd4 static const uint8 restore_fpu_dat[] = {0x55, 0x68, 0x04, 0xa5, 0x4c, 0x82, 0x00, 0x20, 0x81, 0x06, 0x00, 0xe4}; if ((base = find_rom_data(0x310000, 0x314000, restore_fpu_dat, sizeof(restore_fpu_dat))) == 0) return false; D(bug("restore_fpu %08lx\n", base)); if (base != loc) return false; - lp = (uint32 *)(ROM_BASE + base + 4); // Don't modify MSR to turn on FPU + lp = (uint32 *)(ROMBaseHost + base + 4); // Don't modify MSR to turn on FPU *lp++ = htonl(POWERPC_NOP); lp += 2; *lp++ = htonl(POWERPC_NOP); @@ -1386,16 +1386,16 @@ static bool patch_nanokernel(void) static const uint8 trap_return_dat[] = {0x80, 0xc1, 0x00, 0x18, 0x80, 0x21, 0x00, 0x04, 0x4c, 0x00, 0x00, 0x64}; if ((base = find_rom_data(0x312000, 0x320000, trap_return_dat, sizeof(trap_return_dat))) == 0) return false; D(bug("trap_return %08lx\n", base + 8)); - lp = (uint32 *)(ROM_BASE + base + 8); // Replace rfi + lp = (uint32 *)(ROMBaseHost + base + 8); // Replace rfi *lp = htonl(POWERPC_BCTR); while (ntohl(*lp) != 0x7d5a03a6) lp--; *lp++ = htonl(0x7d4903a6); // mtctr r10 *lp++ = htonl(0x7daff120); // mtcr r13 - *lp = htonl(0x48000000 + ((0x318000 - ((uint32)lp - ROM_BASE)) & 0x03fffffc)); // b ROM_BASE+0x318000 - uint32 npc = (uint32)(lp + 1) - ROM_BASE; + *lp = htonl(0x48000000 + ((0x318000 - ((uintptr)lp - (uintptr)ROMBaseHost)) & 0x03fffffc)); // b ROM_BASE+0x318000 + uint32 npc = (uintptr)(lp + 1) - (uintptr)ROMBaseHost; - lp = (uint32 *)(ROM_BASE + 0x318000); + lp = (uint32 *)(ROMBaseHost + 0x318000); *lp++ = htonl(0x81400000 + XLM_IRQ_NEST); // lwz r10,XLM_IRQ_NEST *lp++ = htonl(0x394affff); // subi r10,r10,1 *lp++ = htonl(0x91400000 + XLM_IRQ_NEST); // stw r10,XLM_IRQ_NEST @@ -1426,14 +1426,14 @@ static bool patch_68k(void) static const uint8 reset_dat[] = {0x4e, 0x70}; if ((base = find_rom_data(0xc8, 0x120, reset_dat, sizeof(reset_dat))) == 0) return false; D(bug("reset %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp = htons(M68K_NOP); // Fake reading PowerMac ID (via Universal) static const uint8 powermac_id_dat[] = {0x45, 0xf9, 0x5f, 0xff, 0xff, 0xfc, 0x20, 0x12, 0x72, 0x00}; if ((base = find_rom_data(0xe000, 0x15000, powermac_id_dat, sizeof(powermac_id_dat))) == 0) return false; D(bug("powermac_id %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(0x203c); // move.l #id,d0 *wp++ = htons(0); // if (ROMType == ROMTYPE_NEWWORLD) @@ -1448,7 +1448,7 @@ static bool patch_68k(void) static const uint8 univ_info_dat[] = {0x3f, 0xff, 0x04, 0x00}; if ((base = find_rom_data(0x14000, 0x18000, univ_info_dat, sizeof(univ_info_dat))) == 0) return false; D(bug("universal_info %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base - 0x14); + lp = (uint32 *)(ROMBaseHost + base - 0x14); lp[0x00 >> 2] = htonl(ADDR_MAP_PATCH_SPACE - (base - 0x14)); lp[0x10 >> 2] = htonl(0xcc003d11); // Make it like the PowerMac 9500 UniversalInfo lp[0x14 >> 2] = htonl(0x3fff0401); @@ -1460,7 +1460,7 @@ static bool patch_68k(void) lp[0x60 >> 2] = htonl(0x0000003d); } else if (ROMType == ROMTYPE_ZANZIBAR) { base = 0x12b70; - lp = (uint32 *)(ROM_BASE + base - 0x14); + lp = (uint32 *)(ROMBaseHost + base - 0x14); lp[0x00 >> 2] = htonl(ADDR_MAP_PATCH_SPACE - (base - 0x14)); lp[0x10 >> 2] = htonl(0xcc003d11); // Make it like the PowerMac 9500 UniversalInfo lp[0x14 >> 2] = htonl(0x3fff0401); @@ -1472,7 +1472,7 @@ static bool patch_68k(void) lp[0x60 >> 2] = htonl(0x0000003d); } else if (ROMType == ROMTYPE_GOSSAMER) { base = 0x12d20; - lp = (uint32 *)(ROM_BASE + base - 0x14); + lp = (uint32 *)(ROMBaseHost + base - 0x14); lp[0x00 >> 2] = htonl(ADDR_MAP_PATCH_SPACE - (base - 0x14)); lp[0x10 >> 2] = htonl(0xcc003d11); // Make it like the PowerMac 9500 UniversalInfo lp[0x14 >> 2] = htonl(0x3fff0401); @@ -1486,7 +1486,7 @@ static bool patch_68k(void) // Construct AddrMap for NewWorld ROM if (ROMType == ROMTYPE_NEWWORLD || ROMType == ROMTYPE_ZANZIBAR || ROMType == ROMTYPE_GOSSAMER) { - lp = (uint32 *)(ROM_BASE + ADDR_MAP_PATCH_SPACE); + lp = (uint32 *)(ROMBaseHost + ADDR_MAP_PATCH_SPACE); memset(lp - 10, 0, 0x128); lp[-10] = htonl(0x0300001c); lp[-9] = htonl(0x000108c4); @@ -1510,19 +1510,19 @@ static bool patch_68k(void) static const uint8 via_init_dat[] = {0x08, 0x00, 0x00, 0x02, 0x67, 0x00, 0x00, 0x2c, 0x24, 0x68, 0x00, 0x08}; if ((base = find_rom_data(0xe000, 0x15000, via_init_dat, sizeof(via_init_dat))) == 0) return false; D(bug("via_init %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base + 4); + wp = (uint16 *)(ROMBaseHost + base + 4); *wp = htons(0x6000); // bra static const uint8 via_init2_dat[] = {0x24, 0x68, 0x00, 0x08, 0x00, 0x12, 0x00, 0x30, 0x4e, 0x71}; if ((base = find_rom_data(0xa000, 0x10000, via_init2_dat, sizeof(via_init2_dat))) == 0) return false; D(bug("via_init2 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp = htons(0x4ed6); // jmp (a6) static const uint8 via_init3_dat[] = {0x22, 0x68, 0x00, 0x08, 0x28, 0x3c, 0x20, 0x00, 0x01, 0x00}; if ((base = find_rom_data(0xa000, 0x10000, via_init3_dat, sizeof(via_init3_dat))) == 0) return false; D(bug("via_init3 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp = htons(0x4ed6); // jmp (a6) // Don't RunDiags, get BootGlobs pointer directly @@ -1530,7 +1530,7 @@ static bool patch_68k(void) static const uint8 run_diags_dat[] = {0x60, 0xff, 0x00, 0x0c}; if ((base = find_rom_data(0x110, 0x128, run_diags_dat, sizeof(run_diags_dat))) == 0) return false; D(bug("run_diags %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(0x4df9); // lea xxx,a6 *wp++ = htons((RAMBase + RAMSize - 0x1c) >> 16); *wp = htons((RAMBase + RAMSize - 0x1c) & 0xffff); @@ -1538,7 +1538,7 @@ static bool patch_68k(void) static const uint8 run_diags_dat[] = {0x74, 0x00, 0x2f, 0x0e}; if ((base = find_rom_data(0xd0, 0xf0, run_diags_dat, sizeof(run_diags_dat))) == 0) return false; D(bug("run_diags %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base - 6); + wp = (uint16 *)(ROMBaseHost + base - 6); *wp++ = htons(0x4df9); // lea xxx,a6 *wp++ = htons((RAMBase + RAMSize - 0x1c) >> 16); *wp = htons((RAMBase + RAMSize - 0x1c) & 0xffff); @@ -1548,7 +1548,7 @@ static bool patch_68k(void) static const uint8 nvram1_dat[] = {0x48, 0xe7, 0x01, 0x0e, 0x24, 0x68, 0x00, 0x08, 0x08, 0x83, 0x00, 0x1f}; if ((base = find_rom_data(0x7000, 0xc000, nvram1_dat, sizeof(nvram1_dat))) == 0) return false; D(bug("nvram1 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(M68K_EMUL_OP_XPRAM1); *wp = htons(M68K_RTS); @@ -1556,21 +1556,21 @@ static bool patch_68k(void) static const uint8 nvram2_dat[] = {0x48, 0xe7, 0x1c, 0xe0, 0x4f, 0xef, 0xff, 0xb4}; if ((base = find_rom_data(0xa000, 0xd000, nvram2_dat, sizeof(nvram2_dat))) == 0) return false; D(bug("nvram2 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(M68K_EMUL_OP_XPRAM2); *wp = htons(0x4ed3); // jmp (a3) static const uint8 nvram3_dat[] = {0x48, 0xe7, 0xdc, 0xe0, 0x4f, 0xef, 0xff, 0xb4}; if ((base = find_rom_data(0xa000, 0xd000, nvram3_dat, sizeof(nvram3_dat))) == 0) return false; D(bug("nvram3 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(M68K_EMUL_OP_XPRAM3); *wp = htons(0x4ed3); // jmp (a3) static const uint8 nvram4_dat[] = {0x4e, 0x56, 0xff, 0xa8, 0x48, 0xe7, 0x1f, 0x38, 0x16, 0x2e, 0x00, 0x13}; if ((base = find_rom_data(0xa000, 0xd000, nvram4_dat, sizeof(nvram4_dat))) == 0) return false; D(bug("nvram4 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base + 16); + wp = (uint16 *)(ROMBaseHost + base + 16); *wp++ = htons(0x1a2e); // move.b ($000f,a6),d5 *wp++ = htons(0x000f); *wp++ = htons(M68K_EMUL_OP_NVRAM3); @@ -1583,13 +1583,13 @@ static bool patch_68k(void) static const uint8 nvram5_dat[] = {0x0c, 0x80, 0x03, 0x00, 0x00, 0x00, 0x66, 0x0a, 0x70, 0x00, 0x21, 0xf8, 0x02, 0x0c, 0x01, 0xe4}; if ((base = find_rom_data(0xa000, 0xd000, nvram5_dat, sizeof(nvram5_dat))) == 0) return false; D(bug("nvram5 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base + 6); + wp = (uint16 *)(ROMBaseHost + base + 6); *wp = htons(M68K_NOP); static const uint8 nvram6_dat[] = {0x2f, 0x0a, 0x24, 0x48, 0x4f, 0xef, 0xff, 0xa0, 0x20, 0x0f}; if ((base = find_rom_data(0x9000, 0xb000, nvram6_dat, sizeof(nvram6_dat))) == 0) return false; D(bug("nvram6 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(0x7000); // moveq #0,d0 *wp++ = htons(0x2080); // move.l d0,(a0) *wp++ = htons(0x4228); // clr.b 4(a0) @@ -1600,26 +1600,26 @@ static bool patch_68k(void) base = find_rom_data(0x9000, 0xb000, nvram7_dat, sizeof(nvram7_dat)); if (base) { D(bug("nvram7 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base + 12); + wp = (uint16 *)(ROMBaseHost + base + 12); *wp = htons(M68K_RTS); } } else { static const uint8 nvram2_dat[] = {0x4e, 0xd6, 0x06, 0x41, 0x13, 0x00}; if ((base = find_rom_data(0x7000, 0xb000, nvram2_dat, sizeof(nvram2_dat))) == 0) return false; D(bug("nvram2 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base + 2); + wp = (uint16 *)(ROMBaseHost + base + 2); *wp++ = htons(M68K_EMUL_OP_XPRAM2); *wp = htons(0x4ed3); // jmp (a3) static const uint8 nvram3_dat[] = {0x4e, 0xd3, 0x06, 0x41, 0x13, 0x00}; if ((base = find_rom_data(0x7000, 0xb000, nvram3_dat, sizeof(nvram3_dat))) == 0) return false; D(bug("nvram3 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base + 2); + wp = (uint16 *)(ROMBaseHost + base + 2); *wp++ = htons(M68K_EMUL_OP_XPRAM3); *wp = htons(0x4ed3); // jmp (a3) static const uint32 nvram4_loc[] = {0x582f0, 0xa0a0, 0x7e50, 0xa1d0, 0x538d0, 0}; - wp = (uint16 *)(ROM_BASE + nvram4_loc[ROMType]); + wp = (uint16 *)(ROMBaseHost + nvram4_loc[ROMType]); *wp++ = htons(0x202f); // move.l 4(sp),d0 *wp++ = htons(0x0004); *wp++ = htons(M68K_EMUL_OP_NVRAM1); @@ -1633,7 +1633,7 @@ static bool patch_68k(void) } static const uint32 nvram5_loc[] = {0x58460, 0xa0f0, 0x7f40, 0xa220, 0x53a20, 0}; - wp = (uint16 *)(ROM_BASE + nvram5_loc[ROMType]); + wp = (uint16 *)(ROMBaseHost + nvram5_loc[ROMType]); if (ROMType == ROMTYPE_ZANZIBAR || ROMType == ROMTYPE_GAZELLE) { *wp++ = htons(0x202f); // move.l 4(sp),d0 *wp++ = htons(0x0004); @@ -1656,7 +1656,7 @@ static bool patch_68k(void) static const uint8 mem_top_dat[] = {0x2c, 0x6c, 0xff, 0xec, 0x2a, 0x4c, 0xdb, 0xec, 0xff, 0xf4}; if ((base = find_rom_data(0x120, 0x180, mem_top_dat, sizeof(mem_top_dat))) == 0) return false; D(bug("mem_top %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(M68K_EMUL_OP_FIX_MEMTOP); *wp = htons(M68K_NOP); @@ -1664,12 +1664,12 @@ static bool patch_68k(void) static const uint8 scc_init_caller_dat[] = {0x21, 0xce, 0x01, 0x08, 0x22, 0x78, 0x0d, 0xd8}; if ((base = find_rom_data(0x180, 0x1f0, scc_init_caller_dat, sizeof(scc_init_caller_dat))) == 0) return false; D(bug("scc_init_caller %08lx\n", base + 12)); - wp = (uint16 *)(ROM_BASE + base + 12); - loc = ntohs(wp[1]) + ((uintptr)wp - ROM_BASE) + 2; + wp = (uint16 *)(ROMBaseHost + base + 12); + loc = ntohs(wp[1]) + ((uintptr)wp - (uintptr)ROMBaseHost) + 2; static const uint8 scc_init_dat[] = {0x20, 0x78, 0x01, 0xdc, 0x22, 0x78, 0x01, 0xd8}; if ((base = find_rom_data(loc, loc + 0x80, scc_init_dat, sizeof(scc_init_dat))) == 0) return false; D(bug("scc_init %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(M68K_EMUL_OP_RESET); *wp = htons(M68K_RTS); @@ -1677,18 +1677,18 @@ static bool patch_68k(void) static const uint8 ext_cache_dat[] = {0x4e, 0x7b, 0x00, 0x02}; if ((base = find_rom_data(0x1d0, 0x230, ext_cache_dat, sizeof(ext_cache_dat))) == 0) return false; D(bug("ext_cache %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base + 6); - wp = (uint16 *)(ROM_BASE + ntohl(*lp) + base + 6); + lp = (uint32 *)(ROMBaseHost + base + 6); + wp = (uint16 *)(ROMBaseHost + ntohl(*lp) + base + 6); *wp = htons(M68K_RTS); - lp = (uint32 *)(ROM_BASE + base + 12); - wp = (uint16 *)(ROM_BASE + ntohl(*lp) + base + 12); + lp = (uint32 *)(ROMBaseHost + base + 12); + wp = (uint16 *)(ROMBaseHost + ntohl(*lp) + base + 12); *wp = htons(M68K_RTS); // Fake CPU speed test (SetupTimeK) static const uint8 timek_dat[] = {0x0c, 0x38, 0x00, 0x04, 0x01, 0x2f, 0x6d, 0x3c}; if ((base = find_rom_data(0x400, 0x500, timek_dat, sizeof(timek_dat))) == 0) return false; D(bug("timek %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(0x31fc); // move.w #xxx,TimeDBRA *wp++ = htons(100); *wp++ = htons(0x0d00); @@ -1707,9 +1707,9 @@ static bool patch_68k(void) static const uint8 jump_tab_dat[] = {0x41, 0xfa, 0x00, 0x0e, 0x21, 0xc8, 0x20, 0x10, 0x4e, 0x75}; if ((base = find_rom_data(0x3000, 0x6000, jump_tab_dat, sizeof(jump_tab_dat))) == 0) return false; D(bug("jump_tab %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base + 16); + lp = (uint32 *)(ROMBaseHost + base + 16); for (;;) { - D(bug(" %08lx\n", (uint32)lp - ROM_BASE)); + D(bug(" %08lx\n", (uintptr)lp - (uintptr)ROMBaseHost)); while ((ntohl(*lp) & 0xff000000) == 0xff000000) { *lp = htonl((ntohl(*lp) & (ROM_SIZE-1)) + ROM_BASE); lp++; @@ -1724,7 +1724,7 @@ static bool patch_68k(void) static const uint8 sys_zone_dat[] = {0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x40, 0x00}; if ((base = find_rom_data(0x600, 0x900, sys_zone_dat, sizeof(sys_zone_dat))) == 0) return false; D(bug("sys_zone %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp++ = htonl(RAMBase ? RAMBase : 0x3000); *lp = htonl(RAMBase ? RAMBase + 0x1800 : 0x4800); @@ -1733,7 +1733,7 @@ static bool patch_68k(void) static const uint8 boot_stack_dat[] = {0x08, 0x38, 0x00, 0x06, 0x24, 0x0b}; if ((base = find_rom_data(0x580, 0x800, boot_stack_dat, sizeof(boot_stack_dat))) == 0) return false; D(bug("boot_stack %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(0x207c); // move.l #RAMBase+0x3ffffe,a0 *wp++ = htons((RAMBase + 0x3ffffe) >> 16); *wp++ = htons((RAMBase + 0x3ffffe) & 0xffff); @@ -1744,7 +1744,7 @@ static bool patch_68k(void) static const uint8 page_size_dat[] = {0x20, 0x30, 0x81, 0xf2, 0x5f, 0xff, 0xef, 0xd8, 0x00, 0x10}; if ((base = find_rom_data(0xb000, 0x12000, page_size_dat, sizeof(page_size_dat))) == 0) return false; D(bug("page_size %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(0x203c); // move.l #$1000,d0 *wp++ = htons(0); *wp++ = htons(0x1000); @@ -1755,7 +1755,7 @@ static bool patch_68k(void) static const uint8 page_size2_dat[] = {0x26, 0x79, 0x5f, 0xff, 0xef, 0xd8, 0x25, 0x6b, 0x00, 0x10, 0x00, 0x1e}; if ((base = find_rom_data(0x50000, 0x70000, page_size2_dat, sizeof(page_size2_dat))) == 0) return false; D(bug("page_size2 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(0x257c); // move.l #$1000,$1e(a2) *wp++ = htons(0); *wp++ = htons(0x1000); @@ -1776,21 +1776,21 @@ static bool patch_68k(void) *wp++ = htons(M68K_NOP); *wp = htons(M68K_NOP); if (ROMType == ROMTYPE_NEWWORLD) - wp = (uint16 *)(ROM_BASE + base + 0x4a); + wp = (uint16 *)(ROMBaseHost + base + 0x4a); else - wp = (uint16 *)(ROM_BASE + base + 0x28); + wp = (uint16 *)(ROMBaseHost + base + 0x28); *wp++ = htons(M68K_NOP); *wp = htons(M68K_NOP); // Gestalt CPU/bus clock speed (InitGestalt, via 0x25c) if (ROMType == ROMTYPE_ZANZIBAR) { - wp = (uint16 *)(ROM_BASE + 0x5d87a); + wp = (uint16 *)(ROMBaseHost + 0x5d87a); *wp++ = htons(0x203c); // move.l #Hz,d0 *wp++ = htons(BusClockSpeed >> 16); *wp++ = htons(BusClockSpeed & 0xffff); *wp++ = htons(M68K_NOP); *wp = htons(M68K_NOP); - wp = (uint16 *)(ROM_BASE + 0x5d888); + wp = (uint16 *)(ROMBaseHost + 0x5d888); *wp++ = htons(0x203c); // move.l #Hz,d0 *wp++ = htons(CPUClockSpeed >> 16); *wp++ = htons(CPUClockSpeed & 0xffff); @@ -1803,23 +1803,23 @@ static bool patch_68k(void) static const uint8 gc_mask_dat[] = {0x83, 0xa8, 0x00, 0x24, 0x4e, 0x71}; if ((base = find_rom_data(0x13000, 0x20000, gc_mask_dat, sizeof(gc_mask_dat))) == 0) return false; D(bug("gc_mask %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(M68K_NOP); *wp = htons(M68K_NOP); - wp = (uint16 *)(ROM_BASE + base + 0x40); + wp = (uint16 *)(ROMBaseHost + base + 0x40); *wp++ = htons(M68K_NOP); *wp = htons(M68K_NOP); - wp = (uint16 *)(ROM_BASE + base + 0x78); + wp = (uint16 *)(ROMBaseHost + base + 0x78); *wp++ = htons(M68K_NOP); *wp = htons(M68K_NOP); - wp = (uint16 *)(ROM_BASE + base + 0x96); + wp = (uint16 *)(ROMBaseHost + base + 0x96); *wp++ = htons(M68K_NOP); *wp = htons(M68K_NOP); static const uint8 gc_mask2_dat[] = {0x02, 0xa8, 0x00, 0x00, 0x00, 0x80, 0x00, 0x24}; if ((base = find_rom_data(0x13000, 0x20000, gc_mask2_dat, sizeof(gc_mask2_dat))) == 0) return false; D(bug("gc_mask2 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); if (ROMType == ROMTYPE_GOSSAMER) { *wp++ = htons(M68K_NOP); *wp++ = htons(M68K_NOP); @@ -1848,7 +1848,7 @@ static bool patch_68k(void) static const uint8 cuda_init_dat[] = {0x08, 0xa9, 0x00, 0x04, 0x16, 0x00, 0x4e, 0x71, 0x13, 0x7c, 0x00, 0x84, 0x1c, 0x00, 0x4e, 0x71}; if ((base = find_rom_data(0xa000, 0x12000, cuda_init_dat, sizeof(cuda_init_dat))) == 0) return false; D(bug("cuda_init %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(M68K_NOP); *wp++ = htons(M68K_NOP); *wp++ = htons(M68K_NOP); @@ -1861,14 +1861,14 @@ static bool patch_68k(void) static const uint8 cpu_speed_dat[] = {0x20, 0x30, 0x81, 0xf2, 0x5f, 0xff, 0xef, 0xd8, 0x00, 0x04, 0x4c, 0x7c}; if ((base = find_rom_data(0x6000, 0xa000, cpu_speed_dat, sizeof(cpu_speed_dat))) == 0) return false; D(bug("cpu_speed %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(0x203c); // move.l #(MHz<<16)|MHz,d0 *wp++ = htons(CPUClockSpeed / 1000000); *wp++ = htons(CPUClockSpeed / 1000000); *wp = htons(M68K_RTS); if ((base = find_rom_data(base, 0xa000, cpu_speed_dat, sizeof(cpu_speed_dat))) != 0) { D(bug("cpu_speed2 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(0x203c); // move.l #(MHz<<16)|MHz,d0 *wp++ = htons(CPUClockSpeed / 1000000); *wp++ = htons(CPUClockSpeed / 1000000); @@ -1879,7 +1879,7 @@ static bool patch_68k(void) static const uint8 time_via_dat[] = {0x40, 0xe7, 0x00, 0x7c, 0x07, 0x00, 0x28, 0x78, 0x01, 0xd4, 0x43, 0xec, 0x10, 0x00}; if ((base = find_rom_data(0x30000, 0x40000, time_via_dat, sizeof(time_via_dat))) == 0) return false; D(bug("time_via %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(0x4cdf); // movem.l (sp)+,d0-d5/a0-a4 *wp++ = htons(0x1f3f); *wp = htons(M68K_RTS); @@ -1889,12 +1889,12 @@ static bool patch_68k(void) static const uint8 open_firmware_dat[] = {0x2f, 0x79, 0xff, 0x80, 0x00, 0x00, 0x00, 0xfc}; if ((base = find_rom_data(0x48000, 0x58000, open_firmware_dat, sizeof(open_firmware_dat))) == 0) return false; D(bug("open_firmware %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(0x2f7c); // move.l #deadbeef,0xfc(a7) *wp++ = htons(0xdead); *wp++ = htons(0xbeef); *wp = htons(0x00fc); - wp = (uint16 *)(ROM_BASE + base + 0x1a); + wp = (uint16 *)(ROMBaseHost + base + 0x1a); *wp++ = htons(M68K_NOP); // (FE03 opcode, tries to jump to 0xdeadbeef) *wp = htons(M68K_NOP); @@ -1902,7 +1902,7 @@ static bool patch_68k(void) static const uint8 ext_cache2_dat[] = {0x4f, 0xef, 0xff, 0xec, 0x20, 0x4f, 0x10, 0xbc, 0x00, 0x01, 0x11, 0x7c, 0x00, 0x1b}; if ((base = find_rom_data(0x13000, 0x20000, ext_cache2_dat, sizeof(ext_cache2_dat))) == 0) return false; D(bug("ext_cache2 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp = htons(M68K_RTS); // Don't install Time Manager task for 60Hz interrupt (Enable60HzInts, via 0x2b8) @@ -1910,7 +1910,7 @@ static bool patch_68k(void) static const uint8 tm_task_dat[] = {0x30, 0x3c, 0x4e, 0x2b, 0xa9, 0xc9}; if ((base = find_rom_data(0x2a0, 0x320, tm_task_dat, sizeof(tm_task_dat))) == 0) return false; D(bug("tm_task %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base + 28); + wp = (uint16 *)(ROMBaseHost + base + 28); *wp++ = htons(M68K_NOP); *wp++ = htons(M68K_NOP); *wp++ = htons(M68K_NOP); @@ -1921,7 +1921,7 @@ static bool patch_68k(void) static const uint8 tm_task_dat[] = {0x20, 0x3c, 0x73, 0x79, 0x73, 0x61}; if ((base = find_rom_data(0x280, 0x300, tm_task_dat, sizeof(tm_task_dat))) == 0) return false; D(bug("tm_task %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base - 6); + wp = (uint16 *)(ROMBaseHost + base - 6); *wp++ = htons(M68K_NOP); *wp++ = htons(M68K_NOP); *wp = htons(M68K_NOP); @@ -1938,7 +1938,7 @@ static bool patch_68k(void) if ((base = find_rom_data(dsl_offset, dsl_offset + 0x6000, dsl_pvr_dat, sizeof(dsl_pvr_dat))) == 0) return false; } D(bug("dsl_pvr %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base + 12); + lp = (uint32 *)(ROMBaseHost + base + 12); *lp = htonl(0x3c800000 | (PVR >> 16)); // lis r4,PVR // Don't read bus clock from 0x5fffef88 in DriverServicesLib (via 0x316) @@ -1946,20 +1946,20 @@ static bool patch_68k(void) static const uint8 dsl_bus_dat[] = {0x81, 0x07, 0x00, 0x00, 0x39, 0x20, 0x42, 0x40, 0x81, 0x62, 0xff, 0x20}; if ((base = find_rom_data(dsl_offset, dsl_offset + 0x6000, dsl_bus_dat, sizeof(dsl_bus_dat))) == 0) return false; D(bug("dsl_bus %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp = htonl(0x81000000 + XLM_BUS_CLOCK); // lwz r8,(bus clock speed) } else { static const uint8 dsl_bus_dat[] = {0x80, 0x83, 0xef, 0xe8, 0x80, 0x62, 0x00, 0x10, 0x7c, 0x04, 0x03, 0x96}; if ((base = find_rom_data(dsl_offset, dsl_offset + 0x6000, dsl_bus_dat, sizeof(dsl_bus_dat))) == 0) return false; D(bug("dsl_bus %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp = htonl(0x80800000 + XLM_BUS_CLOCK); // lwz r4,(bus clock speed) } } // Don't open InterruptTreeTNT in MotherBoardHAL init in DriverServicesLib init if (ROMType == ROMTYPE_ZANZIBAR) { - lp = (uint32 *)(ROM_BASE + find_rom_resource(FOURCC('n','l','i','b'), -16408) + 0x16c); + lp = (uint32 *)(ROMBaseHost + find_rom_resource(FOURCC('n','l','i','b'), -16408) + 0x16c); *lp = htonl(0x38600000); // li r3,0 } @@ -1969,7 +1969,7 @@ static bool patch_68k(void) static const uint8 hpchk_dat[] = {0x80, 0x80, 0x03, 0x16, 0x94, 0x21, 0xff, 0xb0, 0x83, 0xc4, 0x00, 0x04}; if ((base = find_rom_data(hpchk_offset, hpchk_offset + 0x3000, hpchk_dat, sizeof(hpchk_dat))) == 0) return false; D(bug("hpchk %08lx\n", base)); - lp = (uint32 *)(ROM_BASE + base); + lp = (uint32 *)(ROMBaseHost + base); *lp = htonl(0x80800000 + XLM_ZERO_PAGE); // lwz r4,(zero page) } @@ -1977,7 +1977,7 @@ static bool patch_68k(void) static const uint8 name_reg_dat[] = {0x70, 0xff, 0xab, 0xeb}; if ((base = find_rom_data(0x300, 0x380, name_reg_dat, sizeof(name_reg_dat))) == 0) return false; D(bug("name_reg %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp = htons(M68K_EMUL_OP_NAME_REGISTRY); #if DISABLE_SCSI @@ -1989,7 +1989,7 @@ static bool patch_68k(void) if ((base = find_rom_data(0x1c000, 0x28000, scsi_mgr_b_dat, sizeof(scsi_mgr_b_dat))) == 0) return false; } D(bug("scsi_mgr %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(0x21fc); // move.l #xxx,0x624 (SCSIAtomic) *wp++ = htons((ROM_BASE + base + 18) >> 16); *wp++ = htons((ROM_BASE + base + 18) & 0xffff); @@ -2003,7 +2003,7 @@ static bool patch_68k(void) *wp++ = htons(M68K_RTS); *wp++ = htons(M68K_EMUL_OP_SCSI_DISPATCH); *wp = htons(0x4ed0); // jmp (a0) - wp = (uint16 *)(ROM_BASE + base + 0x20); + wp = (uint16 *)(ROMBaseHost + base + 0x20); *wp++ = htons(0x7000); // moveq #0,d0 *wp = htons(M68K_RTS); #endif @@ -2015,14 +2015,14 @@ static bool patch_68k(void) static const uint8 scsi_var_dat[] = {0x70, 0x01, 0xa0, 0x89, 0x4a, 0x6e, 0xfe, 0xac, 0x4f, 0xef, 0x00, 0x10, 0x66, 0x00}; if ((base = find_rom_data(0x1f500, 0x1f600, scsi_var_dat, sizeof(scsi_var_dat))) != 0) { D(bug("scsi_var %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base + 12); + wp = (uint16 *)(ROMBaseHost + base + 12); *wp = htons(0x6000); // bra } static const uint8 scsi_var2_dat[] = {0x4e, 0x56, 0xfc, 0x58, 0x48, 0xe7, 0x1f, 0x38}; if ((base = find_rom_data(0x1f700, 0x1f800, scsi_var2_dat, sizeof(scsi_var2_dat))) != 0) { D(bug("scsi_var2 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(0x7000); // moveq #0,d0 *wp = htons(M68K_RTS); } @@ -2031,14 +2031,14 @@ static bool patch_68k(void) static const uint8 scsi_var_dat[] = {0x70, 0x01, 0xa0, 0x89, 0x4a, 0x6e, 0xfe, 0xac, 0x4f, 0xef, 0x00, 0x10, 0x66, 0x00}; if ((base = find_rom_data(0x1d700, 0x1d800, scsi_var_dat, sizeof(scsi_var_dat))) != 0) { D(bug("scsi_var %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base + 12); + wp = (uint16 *)(ROMBaseHost + base + 12); *wp = htons(0x6000); // bra } static const uint8 scsi_var2_dat[] = {0x4e, 0x56, 0xfc, 0x5a, 0x48, 0xe7, 0x1f, 0x38}; if ((base = find_rom_data(0x1d900, 0x1da00, scsi_var2_dat, sizeof(scsi_var2_dat))) != 0) { D(bug("scsi_var2 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(0x7000); // moveq #0,d0 *wp = htons(M68K_RTS); } @@ -2049,25 +2049,25 @@ static bool patch_68k(void) static const uint8 adb_init_dat[] = {0x08, 0x2b, 0x00, 0x05, 0x01, 0x5d, 0x66, 0xf8}; if ((base = find_rom_data(0x31000, 0x3d000, adb_init_dat, sizeof(adb_init_dat))) == 0) return false; D(bug("adb_init %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base + 6); + wp = (uint16 *)(ROMBaseHost + base + 6); *wp = htons(M68K_NOP); // Modify check in InitResources() so that addresses >0x80000000 work static const uint8 init_res_dat[] = {0x4a, 0xb8, 0x0a, 0x50, 0x6e, 0x20}; if ((base = find_rom_data(0x78000, 0x8c000, init_res_dat, sizeof(init_res_dat))) == 0) return false; D(bug("init_res %08lx\n", base)); - bp = (uint8 *)(ROM_BASE + base + 4); + bp = (uint8 *)(ROMBaseHost + base + 4); *bp = 0x66; // Modify vCheckLoad() so that we can patch resources (68k Resource Manager) static const uint8 check_load_dat[] = {0x20, 0x78, 0x07, 0xf0, 0x4e, 0xd0}; if ((base = find_rom_data(0x78000, 0x8c000, check_load_dat, sizeof(check_load_dat))) == 0) return false; D(bug("check_load %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(M68K_JMP); *wp++ = htons((ROM_BASE + CHECK_LOAD_PATCH_SPACE) >> 16); *wp = htons((ROM_BASE + CHECK_LOAD_PATCH_SPACE) & 0xffff); - wp = (uint16 *)(ROM_BASE + CHECK_LOAD_PATCH_SPACE); + wp = (uint16 *)(ROMBaseHost + CHECK_LOAD_PATCH_SPACE); *wp++ = htons(0x2f03); // move.l d3,-(a7) *wp++ = htons(0x2078); // move.l $07f0,a0 *wp++ = htons(0x07f0); @@ -2083,17 +2083,17 @@ static bool patch_68k(void) sony_offset = find_rom_resource(FOURCC('n','d','r','v'), -20196); // NewWorld 1.6 has "PCFloppy" ndrv if (sony_offset == 0) return false; - lp = (uint32 *)(ROM_BASE + rsrc_ptr + 8); + lp = (uint32 *)(ROMBaseHost + rsrc_ptr + 8); *lp = htonl(FOURCC('D','R','V','R')); - wp = (uint16 *)(ROM_BASE + rsrc_ptr + 12); + wp = (uint16 *)(ROMBaseHost + rsrc_ptr + 12); *wp = htons(4); } D(bug("sony_offset %08lx\n", sony_offset)); - memcpy((void *)(ROM_BASE + sony_offset), sony_driver, sizeof(sony_driver)); + memcpy((void *)(ROMBaseHost + sony_offset), sony_driver, sizeof(sony_driver)); // Install .Disk and .AppleCD drivers - memcpy((void *)(ROM_BASE + sony_offset + 0x100), disk_driver, sizeof(disk_driver)); - memcpy((void *)(ROM_BASE + sony_offset + 0x200), cdrom_driver, sizeof(cdrom_driver)); + memcpy((void *)(ROMBaseHost + sony_offset + 0x100), disk_driver, sizeof(disk_driver)); + memcpy((void *)(ROMBaseHost + sony_offset + 0x200), cdrom_driver, sizeof(cdrom_driver)); // Install serial drivers gen_ain_driver( ROM_BASE + sony_offset + 0x300); @@ -2103,64 +2103,64 @@ static bool patch_68k(void) // Copy icons to ROM SonyDiskIconAddr = ROM_BASE + sony_offset + 0x800; - memcpy((void *)(ROM_BASE + sony_offset + 0x800), SonyDiskIcon, sizeof(SonyDiskIcon)); + memcpy(ROMBaseHost + sony_offset + 0x800, SonyDiskIcon, sizeof(SonyDiskIcon)); SonyDriveIconAddr = ROM_BASE + sony_offset + 0xa00; - memcpy((void *)(ROM_BASE + sony_offset + 0xa00), SonyDriveIcon, sizeof(SonyDriveIcon)); + memcpy(ROMBaseHost + sony_offset + 0xa00, SonyDriveIcon, sizeof(SonyDriveIcon)); DiskIconAddr = ROM_BASE + sony_offset + 0xc00; - memcpy((void *)(ROM_BASE + sony_offset + 0xc00), DiskIcon, sizeof(DiskIcon)); + memcpy(ROMBaseHost + sony_offset + 0xc00, DiskIcon, sizeof(DiskIcon)); CDROMIconAddr = ROM_BASE + sony_offset + 0xe00; - memcpy((void *)(ROM_BASE + sony_offset + 0xe00), CDROMIcon, sizeof(CDROMIcon)); + memcpy(ROMBaseHost + sony_offset + 0xe00, CDROMIcon, sizeof(CDROMIcon)); // Patch driver install routine static const uint8 drvr_install_dat[] = {0xa7, 0x1e, 0x21, 0xc8, 0x01, 0x1c, 0x4e, 0x75}; if ((base = find_rom_data(0xb00, 0xd00, drvr_install_dat, sizeof(drvr_install_dat))) == 0) return false; D(bug("drvr_install %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base + 8); + wp = (uint16 *)(ROMBaseHost + base + 8); *wp++ = htons(M68K_EMUL_OP_INSTALL_DRIVERS); *wp = htons(M68K_RTS); // Don't install serial drivers from ROM if (ROMType == ROMTYPE_ZANZIBAR || ROMType == ROMTYPE_NEWWORLD || ROMType == ROMTYPE_GOSSAMER) { - wp = (uint16 *)(ROM_BASE + find_rom_resource(FOURCC('S','E','R','D'), 0)); + wp = (uint16 *)(ROMBaseHost + find_rom_resource(FOURCC('S','E','R','D'), 0)); *wp = htons(M68K_RTS); } else { - wp = (uint16 *)(ROM_BASE + find_rom_resource(FOURCC('s','l','0','5'), 2) + 0xc4); + wp = (uint16 *)(ROMBaseHost + find_rom_resource(FOURCC('s','l','0','5'), 2) + 0xc4); *wp++ = htons(M68K_NOP); *wp++ = htons(M68K_NOP); *wp++ = htons(M68K_NOP); *wp++ = htons(M68K_NOP); *wp = htons(0x7000); // moveq #0,d0 - wp = (uint16 *)(ROM_BASE + find_rom_resource(FOURCC('s','l','0','5'), 2) + 0x8ee); + wp = (uint16 *)(ROMBaseHost + find_rom_resource(FOURCC('s','l','0','5'), 2) + 0x8ee); *wp = htons(M68K_NOP); } uint32 nsrd_offset = find_rom_resource(FOURCC('n','s','r','d'), 1); if (nsrd_offset) { - lp = (uint32 *)(ROM_BASE + rsrc_ptr + 8); + lp = (uint32 *)(ROMBaseHost + rsrc_ptr + 8); *lp = htonl(FOURCC('x','s','r','d')); } // Replace ADBOp() - memcpy((void *)(ROM_BASE + find_rom_trap(0xa07c)), adbop_patch, sizeof(adbop_patch)); + memcpy(ROMBaseHost + find_rom_trap(0xa07c), adbop_patch, sizeof(adbop_patch)); // Replace Time Manager - wp = (uint16 *)(ROM_BASE + find_rom_trap(0xa058)); + wp = (uint16 *)(ROMBaseHost + find_rom_trap(0xa058)); *wp++ = htons(M68K_EMUL_OP_INSTIME); *wp = htons(M68K_RTS); - wp = (uint16 *)(ROM_BASE + find_rom_trap(0xa059)); + wp = (uint16 *)(ROMBaseHost + find_rom_trap(0xa059)); *wp++ = htons(0x40e7); // move sr,-(sp) *wp++ = htons(0x007c); // ori #$0700,sr *wp++ = htons(0x0700); *wp++ = htons(M68K_EMUL_OP_RMVTIME); *wp++ = htons(0x46df); // move (sp)+,sr *wp = htons(M68K_RTS); - wp = (uint16 *)(ROM_BASE + find_rom_trap(0xa05a)); + wp = (uint16 *)(ROMBaseHost + find_rom_trap(0xa05a)); *wp++ = htons(0x40e7); // move sr,-(sp) *wp++ = htons(0x007c); // ori #$0700,sr *wp++ = htons(0x0700); *wp++ = htons(M68K_EMUL_OP_PRIMETIME); *wp++ = htons(0x46df); // move (sp)+,sr *wp = htons(M68K_RTS); - wp = (uint16 *)(ROM_BASE + find_rom_trap(0xa093)); + wp = (uint16 *)(ROMBaseHost + find_rom_trap(0xa093)); *wp++ = htons(M68K_EMUL_OP_MICROSECONDS); *wp = htons(M68K_RTS); @@ -2168,7 +2168,7 @@ static bool patch_68k(void) static const uint8 egret_dat[] = {0x2f, 0x30, 0x81, 0xe2, 0x20, 0x10, 0x00, 0x18}; if ((base = find_rom_data(0xa000, 0x10000, egret_dat, sizeof(egret_dat))) == 0) return false; D(bug("egret %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); *wp++ = htons(0x7000); *wp = htons(M68K_RTS); @@ -2176,7 +2176,7 @@ static bool patch_68k(void) static const uint8 shutdown_dat[] = {0x40, 0xe7, 0x00, 0x7c, 0x07, 0x00, 0x48, 0xe7, 0x3f, 0x00, 0x2c, 0x00, 0x2e, 0x01}; if ((base = find_rom_data(0x30000, 0x40000, shutdown_dat, sizeof(shutdown_dat))) == 0) return false; D(bug("shutdown %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); + wp = (uint16 *)(ROMBaseHost + base); if (ROMType == ROMTYPE_ZANZIBAR) *wp = htons(M68K_RTS); else if (ntohs(wp[-4]) == 0x61ff) @@ -2185,7 +2185,7 @@ static bool patch_68k(void) wp[-2] = htons(0x6000); // bra // Patch PowerOff() - wp = (uint16 *)(ROM_BASE + find_rom_trap(0xa05b)); // PowerOff() + wp = (uint16 *)(ROMBaseHost + find_rom_trap(0xa05b)); // PowerOff() *wp = htons(M68K_EMUL_RETURN); // Patch VIA interrupt handler @@ -2193,7 +2193,7 @@ static bool patch_68k(void) if ((base = find_rom_data(0x13000, 0x1c000, via_int_dat, sizeof(via_int_dat))) == 0) return false; D(bug("via_int %08lx\n", base)); uint32 level1_int = ROM_BASE + base; - wp = (uint16 *)level1_int; // Level 1 handler + wp = (uint16 *)(ROMBaseHost + base); // Level 1 handler *wp++ = htons(0x7002); // moveq #2,d0 (60Hz interrupt) *wp++ = htons(M68K_NOP); *wp++ = htons(M68K_NOP); @@ -2203,7 +2203,7 @@ static bool patch_68k(void) static const uint8 via_int2_dat[] = {0x13, 0x7c, 0x00, 0x02, 0x1a, 0x00, 0x4e, 0x71, 0x52, 0xb8, 0x01, 0x6a}; if ((base = find_rom_data(0x10000, 0x18000, via_int2_dat, sizeof(via_int2_dat))) == 0) return false; D(bug("via_int2 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); // 60Hz handler + wp = (uint16 *)(ROMBaseHost + base); // 60Hz handler *wp++ = htons(M68K_EMUL_OP_IRQ); *wp++ = htons(0x4a80); // tst.l d0 *wp++ = htons(0x6700); // beq xxx @@ -2213,7 +2213,7 @@ static bool patch_68k(void) static const uint8 via_int3_dat[] = {0x48, 0xe7, 0xf0, 0xf0, 0x76, 0x01, 0x60, 0x26}; if ((base = find_rom_data(0x15000, 0x19000, via_int3_dat, sizeof(via_int3_dat))) == 0) return false; D(bug("via_int3 %08lx\n", base)); - wp = (uint16 *)(ROM_BASE + base); // CHRP level 1 handler + wp = (uint16 *)(ROMBaseHost + base); // CHRP level 1 handler *wp++ = htons(M68K_JMP); *wp++ = htons((level1_int - 12) >> 16); *wp = htons((level1_int - 12) & 0xffff); @@ -2221,30 +2221,31 @@ static bool patch_68k(void) // Patch PutScrap() for clipboard exchange with host OS uint32 put_scrap = find_rom_trap(0xa9fe); // PutScrap() - wp = (uint16 *)(ROM_BASE + PUT_SCRAP_PATCH_SPACE); + wp = (uint16 *)(ROMBaseHost + PUT_SCRAP_PATCH_SPACE); *wp++ = htons(M68K_EMUL_OP_PUT_SCRAP); *wp++ = htons(M68K_JMP); *wp++ = htons((ROM_BASE + put_scrap) >> 16); *wp++ = htons((ROM_BASE + put_scrap) & 0xffff); - lp = (uint32 *)(ROM_BASE + 0x22); - lp = (uint32 *)(ROM_BASE + ntohl(*lp)); + lp = (uint32 *)(ROMBaseHost + 0x22); + lp = (uint32 *)(ROMBaseHost + ntohl(*lp)); lp[0xa9fe & 0x3ff] = htonl(PUT_SCRAP_PATCH_SPACE); // Patch GetScrap() for clipboard exchange with host OS uint32 get_scrap = find_rom_trap(0xa9fd); // GetScrap() - wp = (uint16 *)(ROM_BASE + GET_SCRAP_PATCH_SPACE); + wp = (uint16 *)(ROMBaseHost + GET_SCRAP_PATCH_SPACE); *wp++ = htons(M68K_EMUL_OP_GET_SCRAP); *wp++ = htons(M68K_JMP); *wp++ = htons((ROM_BASE + get_scrap) >> 16); *wp++ = htons((ROM_BASE + get_scrap) & 0xffff); - lp = (uint32 *)(ROM_BASE + 0x22); - lp = (uint32 *)(ROM_BASE + ntohl(*lp)); + lp = (uint32 *)(ROMBaseHost + 0x22); + lp = (uint32 *)(ROMBaseHost + ntohl(*lp)); lp[0xa9fd & 0x3ff] = htonl(GET_SCRAP_PATCH_SPACE); // Patch SynchIdleTime() if (PrefsFindBool("idlewait")) { - wp = (uint16 *)(ROM_BASE + find_rom_trap(0xabf7) + 4); // SynchIdleTime() - D(bug("SynchIdleTime at %08lx\n", wp)); + base = find_rom_trap(0xabf7) + 4; // SynchIdleTime() + wp = (uint16 *)(ROMBaseHost + base); + D(bug("SynchIdleTime at %08lx\n", base)); if (ntohs(*wp) == 0x2078) { // movea.l ExpandMem,a0 *wp++ = htons(M68K_EMUL_OP_IDLE_TIME); *wp = htons(M68K_NOP); @@ -2278,7 +2279,7 @@ static bool patch_68k(void) if ((thing = find_rom_resource(sifter_list[i].type, sifter_list[i].id)) != 0) { D(bug(" patching type %08x, id %d\n", sifter_list[i].type, sifter_list[i].id)); // Install 68k glue code - uint16 *wp = (uint16 *)(ROM_BASE + thing); + uint16 *wp = (uint16 *)(ROMBaseHost + thing); *wp++ = htons(0x4e56); *wp++ = htons(0x0000); // link a6,#0 *wp++ = htons(0x48e7); *wp++ = htons(0x8018); // movem.l d0/a3-a4,-(a7) *wp++ = htons(0x266e); *wp++ = htons(0x000c); // movea.l $c(a6),a3 diff --git a/SheepShaver/src/rsrc_patches.cpp b/SheepShaver/src/rsrc_patches.cpp index 2d80fbd4..247b6905 100644 --- a/SheepShaver/src/rsrc_patches.cpp +++ b/SheepShaver/src/rsrc_patches.cpp @@ -117,7 +117,7 @@ void CheckLoad(uint32 type, int16 id, uint16 *p, uint32 size) D(bug("vCheckLoad %c%c%c%c (%08x) ID %d, data %p, size %d\n", type >> 24, (type >> 16) & 0xff, (type >> 8) & 0xff, type & 0xff, type, id, p, size)); // Don't modify resources in ROM - if ((uintptr)p >= ROM_BASE && (uintptr)p <= (ROM_BASE + ROM_SIZE)) + if ((uintptr)p >= (uintptr)ROMBaseHost && (uintptr)p <= (uintptr)(ROMBaseHost + ROM_SIZE)) return; if (type == FOURCC('b','o','o','t') && id == 3) { @@ -468,7 +468,7 @@ void CheckLoad(uint32 type, int16 id, uint16 *p, uint32 size) } else if (type == FOURCC('t','h','n','g')) { // Collect info about used audio sifters - uint32 thing = (uintptr)p; + uint32 thing = Host2MacAddr((uint8 *)p); uint32 c_type = ReadMacInt32(thing); uint32 sub_type = ReadMacInt32(thing + 4); if (c_type == FOURCC('s','d','e','v') && sub_type == FOURCC('s','i','n','g')) { @@ -571,7 +571,7 @@ void check_load_invoc(uint32 type, int16 id, uint32 h) return; uint32 size = ReadMacInt32(p - 2 * 4) & 0xffffff; - CheckLoad(type, id, (uint16 *)p, size); + CheckLoad(type, id, (uint16 *)Mac2HostAddr(p), size); } #ifdef __BEOS__ @@ -756,87 +756,87 @@ void PatchNativeResourceManager(void) uint32 upp = ReadMacInt32(0x1480); if ((upp & 0xffc00000) == ROM_BASE) return; - uint32 *tvec = (uint32 *)ReadMacInt32(upp + 5 * 4); - D(bug(" GetResource() entry %08x, TOC %08x\n", ntohl(tvec[0]), ntohl(tvec[1]))); - *(uint32 *)XLM_RES_LIB_TOC = tvec[1]; - *(uint32 *)XLM_GET_RESOURCE = tvec[0]; + uint32 tvec = ReadMacInt32(upp + 5 * 4); + D(bug(" GetResource() entry %08x, TOC %08x\n", ReadMacInt32(tvec), ReadMacInt32(tvec + 4))); + WriteMacInt32(XLM_RES_LIB_TOC, ReadMacInt32(tvec + 4)); + WriteMacInt32(XLM_GET_RESOURCE, ReadMacInt32(tvec)); #if EMULATED_PPC - tvec[0] = htonl(NativeFunction(NATIVE_GET_RESOURCE)); + WriteMacInt32(tvec, NativeFunction(NATIVE_GET_RESOURCE)); #else #ifdef __BEOS__ uint32 *tvec2 = (uint32 *)get_resource; - tvec[0] = tvec2[0]; - tvec[1] = tvec2[1]; + WriteMacInt32(tvec, tvec2[0]); + WriteMacInt32(tvec + 4, tvec2[1]); #else - tvec[0] = (uint32)get_resource; + WriteMacInt32(tvec, (uint32)get_resource); #endif #endif // Patch native Get1Resource() upp = ReadMacInt32(0x0e7c); - tvec = (uint32 *)ReadMacInt32(upp + 5 * 4); - D(bug(" Get1Resource() entry %08x, TOC %08x\n", ntohl(tvec[0]), ntohl(tvec[1]))); - *(uint32 *)XLM_GET_1_RESOURCE = tvec[0]; + tvec = ReadMacInt32(upp + 5 * 4); + D(bug(" Get1Resource() entry %08x, TOC %08x\n", ReadMacInt32(tvec), ReadMacInt32(tvec + 4))); + WriteMacInt32(XLM_GET_1_RESOURCE, ReadMacInt32(tvec)); #if EMULATED_PPC - tvec[0] = htonl(NativeFunction(NATIVE_GET_1_RESOURCE)); + WriteMacInt32(tvec, NativeFunction(NATIVE_GET_1_RESOURCE)); #else #ifdef __BEOS__ tvec2 = (uint32 *)get_1_resource; - tvec[0] = tvec2[0]; - tvec[1] = tvec2[1]; + WriteMacInt32(tvec, tvec2[0]); + WriteMacInt32(tvec + 4, tvec2[1]); #else - tvec[0] = (uint32)get_1_resource; + WriteMacInt32(tvec, (uint32)get_1_resource); #endif #endif // Patch native GetIndResource() upp = ReadMacInt32(0x1474); - tvec = (uint32 *)ReadMacInt32(upp + 5 * 4); - D(bug(" GetIndResource() entry %08x, TOC %08x\n", ntohl(tvec[0]), ntohl(tvec[1]))); - *(uint32 *)XLM_GET_IND_RESOURCE = tvec[0]; + tvec = ReadMacInt32(upp + 5 * 4); + D(bug(" GetIndResource() entry %08x, TOC %08x\n", ReadMacInt32(tvec), ReadMacInt32(tvec + 4))); + WriteMacInt32(XLM_GET_IND_RESOURCE, ReadMacInt32(tvec)); #if EMULATED_PPC - tvec[0] = htonl(NativeFunction(NATIVE_GET_IND_RESOURCE)); + WriteMacInt32(tvec, NativeFunction(NATIVE_GET_IND_RESOURCE)); #else #ifdef __BEOS__ tvec2 = (uint32 *)get_ind_resource; - tvec[0] = tvec2[0]; - tvec[1] = tvec2[1]; + WriteMacInt32(tvec, tvec2[0]); + WriteMacInt32(tvec + 4, tvec2[1]); #else - tvec[0] = (uint32)get_ind_resource; + WriteMacInt32(tvec, (uint32)get_ind_resource); #endif #endif // Patch native Get1IndResource() upp = ReadMacInt32(0x0e38); - tvec = (uint32 *)ReadMacInt32(upp + 5 * 4); - D(bug(" Get1IndResource() entry %08x, TOC %08x\n", ntohl(tvec[0]), ntohl(tvec[1]))); - *(uint32 *)XLM_GET_1_IND_RESOURCE = tvec[0]; + tvec = ReadMacInt32(upp + 5 * 4); + D(bug(" Get1IndResource() entry %08x, TOC %08x\n", ReadMacInt32(tvec), ReadMacInt32(tvec + 4))); + WriteMacInt32(XLM_GET_1_IND_RESOURCE, ReadMacInt32(tvec)); #if EMULATED_PPC - tvec[0] = htonl(NativeFunction(NATIVE_GET_1_IND_RESOURCE)); + WriteMacInt32(tvec, NativeFunction(NATIVE_GET_1_IND_RESOURCE)); #else #ifdef __BEOS__ tvec2 = (uint32 *)get_1_ind_resource; - tvec[0] = tvec2[0]; - tvec[1] = tvec2[1]; + WriteMacInt32(tvec, tvec2[0]); + WriteMacInt32(tvec + 4, tvec2[1]); #else - tvec[0] = (uint32)get_1_ind_resource; + WriteMacInt32(tvec, (uint32)get_1_ind_resource); #endif #endif // Patch native RGetResource() upp = ReadMacInt32(0x0e30); - tvec = (uint32 *)ReadMacInt32(upp + 5 * 4); - D(bug(" RGetResource() entry %08x, TOC %08x\n", ntohl(tvec[0]), ntohl(tvec[1]))); - *(uint32 *)XLM_R_GET_RESOURCE = tvec[0]; + tvec = ReadMacInt32(upp + 5 * 4); + D(bug(" RGetResource() entry %08x, TOC %08x\n", ReadMacInt32(tvec), ReadMacInt32(tvec + 4))); + WriteMacInt32(XLM_R_GET_RESOURCE, ReadMacInt32(tvec)); #if EMULATED_PPC - tvec[0] = htonl(NativeFunction(NATIVE_R_GET_RESOURCE)); + WriteMacInt32(tvec, NativeFunction(NATIVE_R_GET_RESOURCE)); #else #ifdef __BEOS__ tvec2 = (uint32 *)r_get_resource; - tvec[0] = tvec2[0]; - tvec[1] = tvec2[1]; + WriteMacInt32(tvec, tvec2[0]); + WriteMacInt32(tvec + 4, tvec2[1]); #else - tvec[0] = (uint32)r_get_resource; + WriteMacInt32(tvec, (uint32)r_get_resource); #endif #endif } diff --git a/SheepShaver/src/thunks.cpp b/SheepShaver/src/thunks.cpp index b63a2a7f..49024f87 100644 --- a/SheepShaver/src/thunks.cpp +++ b/SheepShaver/src/thunks.cpp @@ -149,7 +149,7 @@ static void generate_powerpc_thunks(void) assert(xlm_index != -1 && check_load_invoc_index != -1); uint32 check_load_invoc_opcode = NativeOpcode(NATIVE_CHECK_LOAD_INVOC); - uintptr base; + uint32 base; // GetResource() get_resource_func = base = SheepMem::Reserve(get_resource_template_size); diff --git a/SheepShaver/src/video.cpp b/SheepShaver/src/video.cpp index 09fcfc99..513edd6a 100644 --- a/SheepShaver/src/video.cpp +++ b/SheepShaver/src/video.cpp @@ -74,15 +74,15 @@ static long save_conf_mode = APPLE_8_BIT; // Function pointers of imported functions typedef int16 (*iocic_ptr)(void *, int16); static uint32 iocic_tvect = 0; -static inline int16 IOCommandIsComplete(void *arg1, int16 arg2) +static inline int16 IOCommandIsComplete(uintptr arg1, int16 arg2) { - return (int16)CallMacOS2(iocic_ptr, iocic_tvect, arg1, arg2); + return (int16)CallMacOS2(iocic_ptr, iocic_tvect, (void *)arg1, arg2); } typedef int16 (*vslnewis_ptr)(void *, uint32, uint32 *); static uint32 vslnewis_tvect = 0; -static inline int16 VSLNewInterruptService(void *arg1, uint32 arg2, uint32 *arg3) +static inline int16 VSLNewInterruptService(uintptr arg1, uint32 arg2, uintptr arg3) { - return (int16)CallMacOS3(vslnewis_ptr, vslnewis_tvect, arg1, arg2, arg3); + return (int16)CallMacOS3(vslnewis_ptr, vslnewis_tvect, (void *)arg1, arg2, (uint32 *)arg3); } typedef int16 (*vsldisposeis_ptr)(uint32); static uint32 vsldisposeis_tvect = 0; @@ -98,9 +98,9 @@ int16 VSLDoInterruptService(uint32 arg1) } typedef void (*nqdmisc_ptr)(uint32, void *); static uint32 nqdmisc_tvect = 0; -void NQDMisc(uint32 arg1, void *arg2) +void NQDMisc(uint32 arg1, uintptr arg2) { - CallMacOS2(nqdmisc_ptr, nqdmisc_tvect, arg1, arg2); + CallMacOS2(nqdmisc_ptr, nqdmisc_tvect, arg1, (void *)arg2); } @@ -169,7 +169,7 @@ static int16 VideoOpen(uint32 pb, VidLocals *csSave) // Install and activate interrupt service SheepVar32 theServiceID = 0; - VSLNewInterruptService(csSave->regEntryID, FOURCC('v','b','l',' '), (uint32 *)theServiceID.addr()); + VSLNewInterruptService(Host2MacAddr((uint8 *)csSave->regEntryID), FOURCC('v','b','l',' '), theServiceID.addr()); csSave->vslServiceID = theServiceID.value(); D(bug(" Interrupt ServiceID %08lx\n", csSave->vslServiceID)); csSave->interruptsEnabled = true; @@ -184,6 +184,7 @@ static int16 VideoOpen(uint32 pb, VidLocals *csSave) static int16 set_gamma(VidLocals *csSave, uint32 gamma) { +#warning "FIXME: this code is not little endian aware" GammaTbl *clientGamma = (GammaTbl *)gamma; GammaTbl *gammaTable = csSave->gammaTable; @@ -876,9 +877,9 @@ static int16 VideoClose(uint32 pb, VidLocals *csSave) * Native (PCI) driver entry */ -int16 VideoDoDriverIO(void *spaceID, void *commandID, void *commandContents, uint32 commandCode, uint32 commandKind) +int16 VideoDoDriverIO(uint32 spaceID, uint32 commandID, uint32 commandContents, uint32 commandCode, uint32 commandKind) { -// D(bug("VideoDoDriverIO space %p, command %p, contents %p, code %d, kind %d\n", spaceID, commandID, commandContents, commandCode, commandKind)); +// D(bug("VideoDoDriverIO space %08x, command %08x, contents %08x, code %d, kind %d\n", spaceID, commandID, commandContents, commandCode, commandKind)); int16 err = noErr; switch (commandCode) { @@ -926,7 +927,7 @@ int16 VideoDoDriverIO(void *spaceID, void *commandID, void *commandContents, uin private_data = new VidLocals; private_data->gammaTable = NULL; - memcpy(private_data->regEntryID, (uint8 *)commandContents + 2, 16); // DriverInitInfo.deviceEntry + Mac2Host_memcpy(&private_data->regEntryID, commandContents + 2, 16); // DriverInitInfo.deviceEntry private_data->interruptsEnabled = false; // Disable interrupts break; @@ -939,19 +940,19 @@ int16 VideoDoDriverIO(void *spaceID, void *commandID, void *commandContents, uin break; case kOpenCommand: - err = VideoOpen((uint32)commandContents, private_data); + err = VideoOpen(commandContents, private_data); break; case kCloseCommand: - err = VideoClose((uint32)commandContents, private_data); + err = VideoClose(commandContents, private_data); break; case kControlCommand: - err = VideoControl((uint32)commandContents, private_data); + err = VideoControl(commandContents, private_data); break; case kStatusCommand: - err = VideoStatus((uint32)commandContents, private_data); + err = VideoStatus(commandContents, private_data); break; case kReadCommand: