diff --git a/emulator/emulator.hpp b/emulator/emulator.hpp index 8c04c9a3..eba18649 100644 --- a/emulator/emulator.hpp +++ b/emulator/emulator.hpp @@ -8,7 +8,7 @@ using namespace nall; namespace Emulator { static const string Name = "higan"; - static const string Version = "094.28"; + static const string Version = "094.29"; static const string Author = "byuu"; static const string License = "GPLv3"; static const string Website = "http://byuu.org/"; diff --git a/hiro/extension/browser-dialog.cpp b/hiro/extension/browser-dialog.cpp index e804c62a..758d13c9 100644 --- a/hiro/extension/browser-dialog.cpp +++ b/hiro/extension/browser-dialog.cpp @@ -149,6 +149,7 @@ auto BrowserDialogWindow::run() -> lstring { window.setCentered(state.parent); window.setVisible(); view.resizeColumns(); + view.setFocused(); window.setModal(); window.setVisible(false); diff --git a/hiro/gtk/application.cpp b/hiro/gtk/application.cpp index ec92c4ed..21323b82 100644 --- a/hiro/gtk/application.cpp +++ b/hiro/gtk/application.cpp @@ -2,15 +2,15 @@ namespace hiro { -#if defined(PLATFORM_XORG) +#if defined(DISPLAY_XORG) XlibDisplay* pApplication::display = nullptr; #endif void pApplication::run() { if(Application::state.onMain) { - while(Application::state.quit == false) { - processEvents(); + while(!Application::state.quit) { Application::doMain(); + processEvents(); } } else { gtk_main(); @@ -29,7 +29,7 @@ void pApplication::quit() { //if gtk_main() was invoked, call gtk_main_quit() if(gtk_main_level()) gtk_main_quit(); - #if defined(PLATFORM_XORG) + #if defined(DISPLAY_XORG) //todo: Keyboard::poll() is being called after Application::quit(); //so if display is closed; this causes a segfault //XCloseDisplay(display); @@ -38,7 +38,7 @@ void pApplication::quit() { } void pApplication::initialize() { - #if defined(PLATFORM_XORG) + #if defined(DISPLAY_XORG) display = XOpenDisplay(nullptr); #endif @@ -69,7 +69,7 @@ void pApplication::initialize() { g_type_class_unref(g_type_class_ref(GTK_TYPE_BUTTON)); g_object_set(gtkSettings, "gtk-button-images", true, nullptr); - #if defined(PLATFORM_WINDOWS) + #if defined(DISPLAY_WINDOWS) //there is a serious bug in GTK 2.24 for Windows with the "ime" (Windows IME) input method: //by default, it will be impossible to type in text fields at all. //there are various tricks to get around this; but they are unintuitive and unreliable. diff --git a/hiro/gtk/application.hpp b/hiro/gtk/application.hpp index a8f8ea24..31247606 100644 --- a/hiro/gtk/application.hpp +++ b/hiro/gtk/application.hpp @@ -3,7 +3,7 @@ namespace hiro { struct pApplication { - #if defined(PLATFORM_XORG) + #if defined(DISPLAY_XORG) static XlibDisplay* display; #endif diff --git a/hiro/gtk/desktop.cpp b/hiro/gtk/desktop.cpp index 11f1af65..c22b06e8 100644 --- a/hiro/gtk/desktop.cpp +++ b/hiro/gtk/desktop.cpp @@ -10,13 +10,13 @@ Size pDesktop::size() { } Geometry pDesktop::workspace() { - #if defined(PLATFORM_WINDOWS) + #if defined(DISPLAY_WINDOWS) RECT rc; SystemParametersInfo(SPI_GETWORKAREA, 0, &rc, 0); return {rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top}; #endif - #if defined(PLATFORM_XORG) + #if defined(DISPLAY_XORG) XlibDisplay* display = XOpenDisplay(nullptr); int screen = DefaultScreen(display); diff --git a/hiro/gtk/header.hpp b/hiro/gtk/header.hpp index 1af33fb1..30ec860b 100644 --- a/hiro/gtk/header.hpp +++ b/hiro/gtk/header.hpp @@ -1,4 +1,4 @@ -#if defined(PLATFORM_WINDOWS) +#if defined(DISPLAY_WINDOWS) #define UNICODE #define WINVER 0x0601 #define _WIN32_WINNT WINVER @@ -20,15 +20,15 @@ #include #include #if defined(Hiro_SourceEdit) - #include - #include - #include + #include + #include + #include #endif #include #include #endif -#if defined(PLATFORM_XORG) +#if defined(DISPLAY_XORG) #include #include #include @@ -37,9 +37,9 @@ #include #include #if defined(Hiro_SourceEdit) - #include - #include - #include + #include + #include + #include #endif #include #endif diff --git a/hiro/gtk/keyboard.cpp b/hiro/gtk/keyboard.cpp index 8d0390d2..90315abf 100644 --- a/hiro/gtk/keyboard.cpp +++ b/hiro/gtk/keyboard.cpp @@ -5,7 +5,7 @@ namespace hiro { auto pKeyboard::poll() -> vector { vector result; char state[256]; - #if defined(PLATFORM_XORG) + #if defined(DISPLAY_XORG) XQueryKeymap(pApplication::display, state); #endif for(auto& code : settings->keycodes) { @@ -16,7 +16,7 @@ auto pKeyboard::poll() -> vector { auto pKeyboard::pressed(unsigned code) -> bool { char state[256]; - #if defined(PLATFORM_XORG) + #if defined(DISPLAY_XORG) XQueryKeymap(pApplication::display, state); #endif return _pressed(state, code); @@ -26,12 +26,12 @@ auto pKeyboard::_pressed(const char* state, uint16_t code) -> bool { uint8_t lo = code >> 0; uint8_t hi = code >> 8; - #if defined(PLATFORM_WINDOWS) + #if defined(DISPLAY_WINDOWS) if(lo && GetAsyncKeyState(lo) & 0x8000) return true; if(hi && GetAsyncKeyState(hi) & 0x8000) return true; #endif - #if defined(PLATFORM_XORG) + #if defined(DISPLAY_XORG) if(lo && state[lo >> 3] & (1 << (lo & 7))) return true; if(hi && state[hi >> 3] & (1 << (hi & 7))) return true; #endif @@ -223,7 +223,7 @@ auto pKeyboard::_translate(unsigned code) -> signed { auto pKeyboard::initialize() -> void { auto append = [](unsigned lo, unsigned hi = 0) { - #if defined(PLATFORM_XORG) + #if defined(DISPLAY_XORG) lo = lo ? (uint8_t)XKeysymToKeycode(pApplication::display, lo) : 0; hi = hi ? (uint8_t)XKeysymToKeycode(pApplication::display, hi) : 0; #endif @@ -232,11 +232,11 @@ auto pKeyboard::initialize() -> void { #define map(name, ...) if(key == name) { append(__VA_ARGS__); continue; } for(auto& key : Keyboard::keys) { - #if defined(PLATFORM_WINDOWS) + #if defined(DISPLAY_WINDOWS) #include #endif - #if defined(PLATFORM_XORG) + #if defined(DISPLAY_XORG) #include #endif diff --git a/hiro/gtk/mouse.cpp b/hiro/gtk/mouse.cpp index ca3c288a..645d9b7b 100644 --- a/hiro/gtk/mouse.cpp +++ b/hiro/gtk/mouse.cpp @@ -3,13 +3,13 @@ namespace hiro { auto pMouse::position() -> Position { - #if defined(PLATFORM_WINDOWS) - POINT point = {0}; + #if defined(DISPLAY_WINDOWS) + POINT point{0}; GetCursorPos(&point); return {point.x, point.y}; #endif - #if defined(PLATFORM_XORG) + #if defined(DISPLAY_XORG) XlibWindow root, child; int rootx, rooty, winx, winy; unsigned int mask; @@ -19,7 +19,7 @@ auto pMouse::position() -> Position { } auto pMouse::pressed(Mouse::Button button) -> bool { - #if defined(PLATFORM_WINDOWS) + #if defined(DISPLAY_WINDOWS) switch(button) { case Mouse::Button::Left: return GetAsyncKeyState(VK_LBUTTON) & 0x8000; case Mouse::Button::Middle: return GetAsyncKeyState(VK_MBUTTON) & 0x8000; @@ -27,7 +27,7 @@ auto pMouse::pressed(Mouse::Button button) -> bool { } #endif - #if defined(PLATFORM_XORG) + #if defined(DISPLAY_XORG) XlibWindow root, child; int rootx, rooty, winx, winy; unsigned int mask; diff --git a/hiro/gtk/widget/viewport.cpp b/hiro/gtk/widget/viewport.cpp index 9f4d28ee..8d52e909 100644 --- a/hiro/gtk/widget/viewport.cpp +++ b/hiro/gtk/widget/viewport.cpp @@ -67,11 +67,11 @@ auto pViewport::destruct() -> void { } auto pViewport::handle() const -> uintptr_t { - #if defined(PLATFORM_WINDOWS) + #if defined(DISPLAY_WINDOWS) return (uintptr_t)GDK_WINDOW_HWND(gtk_widget_get_window(gtkWidget)); #endif - #if defined(PLATFORM_XORG) + #if defined(DISPLAY_XORG) return GDK_WINDOW_XID(gtk_widget_get_window(gtkWidget)); #endif } diff --git a/hiro/gtk/window.cpp b/hiro/gtk/window.cpp index 787e5f19..6c40acb9 100644 --- a/hiro/gtk/window.cpp +++ b/hiro/gtk/window.cpp @@ -281,13 +281,13 @@ auto pWindow::setGeometry(Geometry geometry) -> void { auto pWindow::setModal(bool modal) -> void { if(modal) { gtk_window_set_modal(GTK_WINDOW(widget), true); - while(state().modal) { - Application::processEvents(); + while(!Application::state.quit && state().modal) { if(Application::state.onMain) { Application::doMain(); } else { usleep(20 * 1000); } + Application::processEvents(); } gtk_window_set_modal(GTK_WINDOW(widget), false); } diff --git a/libco/amd64.c b/libco/amd64.c index 5f1cfca9..37122f44 100644 --- a/libco/amd64.c +++ b/libco/amd64.c @@ -1,11 +1,16 @@ /* - libco.amd64 (2009-10-12) + libco.amd64 (2015-06-19) author: byuu license: public domain */ #define LIBCO_C #include "libco.h" + +//Win64 only: provides a substantial speed-up, but will thrash XMM regs +//do not use this unless you are certain your application won't use SSE +//#define LIBCO_AMD64_NO_SSE + #include #include @@ -18,21 +23,54 @@ static thread_local cothread_t co_active_handle = 0; static void (*co_swap)(cothread_t, cothread_t) = 0; #ifdef _WIN32 - //ABI: Win64 + /* ABI: Win64 */ static unsigned char co_swap_function[] = { - 0x48, 0x89, 0x22, 0x48, 0x8B, 0x21, 0x58, 0x48, 0x89, 0x6A, 0x08, 0x48, 0x89, 0x72, 0x10, 0x48, - 0x89, 0x7A, 0x18, 0x48, 0x89, 0x5A, 0x20, 0x4C, 0x89, 0x62, 0x28, 0x4C, 0x89, 0x6A, 0x30, 0x4C, - 0x89, 0x72, 0x38, 0x4C, 0x89, 0x7A, 0x40, 0x48, 0x81, 0xC2, 0x80, 0x00, 0x00, 0x00, 0x48, 0x83, - 0xE2, 0xF0, 0x0F, 0x29, 0x32, 0x0F, 0x29, 0x7A, 0x10, 0x44, 0x0F, 0x29, 0x42, 0x20, 0x44, 0x0F, - 0x29, 0x4A, 0x30, 0x44, 0x0F, 0x29, 0x52, 0x40, 0x44, 0x0F, 0x29, 0x5A, 0x50, 0x44, 0x0F, 0x29, - 0x62, 0x60, 0x44, 0x0F, 0x29, 0x6A, 0x70, 0x44, 0x0F, 0x29, 0xB2, 0x80, 0x00, 0x00, 0x00, 0x44, - 0x0F, 0x29, 0xBA, 0x90, 0x00, 0x00, 0x00, 0x48, 0x8B, 0x69, 0x08, 0x48, 0x8B, 0x71, 0x10, 0x48, - 0x8B, 0x79, 0x18, 0x48, 0x8B, 0x59, 0x20, 0x4C, 0x8B, 0x61, 0x28, 0x4C, 0x8B, 0x69, 0x30, 0x4C, - 0x8B, 0x71, 0x38, 0x4C, 0x8B, 0x79, 0x40, 0x48, 0x81, 0xC1, 0x80, 0x00, 0x00, 0x00, 0x48, 0x83, - 0xE1, 0xF0, 0x0F, 0x29, 0x31, 0x0F, 0x29, 0x79, 0x10, 0x44, 0x0F, 0x29, 0x41, 0x20, 0x44, 0x0F, - 0x29, 0x49, 0x30, 0x44, 0x0F, 0x29, 0x51, 0x40, 0x44, 0x0F, 0x29, 0x59, 0x50, 0x44, 0x0F, 0x29, - 0x61, 0x60, 0x44, 0x0F, 0x29, 0x69, 0x70, 0x44, 0x0F, 0x29, 0xB1, 0x80, 0x00, 0x00, 0x00, 0x44, - 0x0F, 0x29, 0xB9, 0x90, 0x00, 0x00, 0x00, 0xFF, 0xE0, + 0x48, 0x89, 0x22, /* mov [rdx],rsp */ + 0x48, 0x8b, 0x21, /* mov rsp,[rcx] */ + 0x58, /* pop rax */ + 0x48, 0x89, 0x6a, 0x08, /* mov [rdx+ 8],rbp */ + 0x48, 0x89, 0x72, 0x10, /* mov [rdx+16],rsi */ + 0x48, 0x89, 0x7a, 0x18, /* mov [rdx+24],rdi */ + 0x48, 0x89, 0x5a, 0x20, /* mov [rdx+32],rbx */ + 0x4c, 0x89, 0x62, 0x28, /* mov [rdx+40],r12 */ + 0x4c, 0x89, 0x6a, 0x30, /* mov [rdx+48],r13 */ + 0x4c, 0x89, 0x72, 0x38, /* mov [rdx+56],r14 */ + 0x4c, 0x89, 0x7a, 0x40, /* mov [rdx+64],r15 */ + #if !defined(LIBCO_AMD64_NO_SSE) + 0x0f, 0x29, 0x72, 0x50, /* movaps [rdx+ 80],xmm6 */ + 0x0f, 0x29, 0x7a, 0x60, /* movaps [rdx+ 96],xmm7 */ + 0x44, 0x0f, 0x29, 0x42, 0x70, /* movaps [rdx+112],xmm8 */ + 0x48, 0x83, 0xc2, 0x70, /* add rdx,112 */ + 0x44, 0x0f, 0x29, 0x4a, 0x10, /* movaps [rdx+ 16],xmm9 */ + 0x44, 0x0f, 0x29, 0x52, 0x20, /* movaps [rdx+ 32],xmm10 */ + 0x44, 0x0f, 0x29, 0x5a, 0x30, /* movaps [rdx+ 48],xmm11 */ + 0x44, 0x0f, 0x29, 0x62, 0x40, /* movaps [rdx+ 64],xmm12 */ + 0x44, 0x0f, 0x29, 0x6a, 0x50, /* movaps [rdx+ 80],xmm13 */ + 0x44, 0x0f, 0x29, 0x72, 0x60, /* movaps [rdx+ 96],xmm14 */ + 0x44, 0x0f, 0x29, 0x7a, 0x70, /* movaps [rdx+112],xmm15 */ + #endif + 0x48, 0x8b, 0x69, 0x08, /* mov rbp,[rcx+ 8] */ + 0x48, 0x8b, 0x71, 0x10, /* mov rsi,[rcx+16] */ + 0x48, 0x8b, 0x79, 0x18, /* mov rdi,[rcx+24] */ + 0x48, 0x8b, 0x59, 0x20, /* mov rbx,[rcx+32] */ + 0x4c, 0x8b, 0x61, 0x28, /* mov r12,[rcx+40] */ + 0x4c, 0x8b, 0x69, 0x30, /* mov r13,[rcx+48] */ + 0x4c, 0x8b, 0x71, 0x38, /* mov r14,[rcx+56] */ + 0x4c, 0x8b, 0x79, 0x40, /* mov r15,[rcx+64] */ + #if !defined(LIBCO_AMD64_NO_SSE) + 0x0f, 0x28, 0x71, 0x50, /* movaps xmm6, [rcx+ 80] */ + 0x0f, 0x28, 0x79, 0x60, /* movaps xmm7, [rcx+ 96] */ + 0x44, 0x0f, 0x28, 0x41, 0x70, /* movaps xmm8, [rcx+112] */ + 0x48, 0x83, 0xc1, 0x70, /* add rcx,112 */ + 0x44, 0x0f, 0x28, 0x49, 0x10, /* movaps xmm9, [rcx+ 16] */ + 0x44, 0x0f, 0x28, 0x51, 0x20, /* movaps xmm10,[rcx+ 32] */ + 0x44, 0x0f, 0x28, 0x59, 0x30, /* movaps xmm11,[rcx+ 48] */ + 0x44, 0x0f, 0x28, 0x61, 0x40, /* movaps xmm12,[rcx+ 64] */ + 0x44, 0x0f, 0x28, 0x69, 0x50, /* movaps xmm13,[rcx+ 80] */ + 0x44, 0x0f, 0x28, 0x71, 0x60, /* movaps xmm14,[rcx+ 96] */ + 0x44, 0x0f, 0x28, 0x79, 0x70, /* movaps xmm15,[rcx+112] */ + #endif + 0xff, 0xe0, /* jmp rax */ }; #include @@ -42,12 +80,24 @@ static void (*co_swap)(cothread_t, cothread_t) = 0; VirtualProtect(co_swap_function, sizeof co_swap_function, PAGE_EXECUTE_READWRITE, &old_privileges); } #else - //ABI: SystemV + /* ABI: SystemV */ static unsigned char co_swap_function[] = { - 0x48, 0x89, 0x26, 0x48, 0x8B, 0x27, 0x58, 0x48, 0x89, 0x6E, 0x08, 0x48, 0x89, 0x5E, 0x10, 0x4C, - 0x89, 0x66, 0x18, 0x4C, 0x89, 0x6E, 0x20, 0x4C, 0x89, 0x76, 0x28, 0x4C, 0x89, 0x7E, 0x30, 0x48, - 0x8B, 0x6F, 0x08, 0x48, 0x8B, 0x5F, 0x10, 0x4C, 0x8B, 0x67, 0x18, 0x4C, 0x8B, 0x6F, 0x20, 0x4C, - 0x8B, 0x77, 0x28, 0x4C, 0x8B, 0x7F, 0x30, 0xFF, 0xE0, + 0x48, 0x89, 0x26, /* mov [rsi],rsp */ + 0x48, 0x8b, 0x27, /* mov rsp,[rdi] */ + 0x58, /* pop rax */ + 0x48, 0x89, 0x6e, 0x08, /* mov [rsi+ 8],rbp */ + 0x48, 0x89, 0x5e, 0x10, /* mov [rsi+16],rbx */ + 0x4c, 0x89, 0x66, 0x18, /* mov [rsi+24],r12 */ + 0x4c, 0x89, 0x6e, 0x20, /* mov [rsi+32],r13 */ + 0x4c, 0x89, 0x76, 0x28, /* mov [rsi+40],r14 */ + 0x4c, 0x89, 0x7e, 0x30, /* mov [rsi+48],r15 */ + 0x48, 0x8b, 0x6f, 0x08, /* mov rbp,[rdi+ 8] */ + 0x48, 0x8b, 0x5f, 0x10, /* mov rbx,[rdi+16] */ + 0x4c, 0x8b, 0x67, 0x18, /* mov r12,[rdi+24] */ + 0x4c, 0x8b, 0x6f, 0x20, /* mov r13,[rdi+32] */ + 0x4c, 0x8b, 0x77, 0x28, /* mov r14,[rdi+40] */ + 0x4c, 0x8b, 0x7f, 0x30, /* mov r15,[rdi+48] */ + 0xff, 0xe0, /* jmp rax */ }; #include @@ -62,7 +112,7 @@ static void (*co_swap)(cothread_t, cothread_t) = 0; #endif static void crash() { - assert(0); /* called only if cothread_t entrypoint returns */ + assert(0); /* called only if cothread_t entrypoint returns */ } cothread_t co_active() { @@ -77,14 +127,14 @@ cothread_t co_create(unsigned int size, void (*entrypoint)(void)) { co_swap = (void (*)(cothread_t, cothread_t))co_swap_function; } if(!co_active_handle) co_active_handle = &co_active_buffer; - size += 512; /* allocate additional space for storage */ - size &= ~15; /* align stack to 16-byte boundary */ + size += 512; /* allocate additional space for storage */ + size &= ~15; /* align stack to 16-byte boundary */ if(handle = (cothread_t)malloc(size)) { - long long *p = (long long*)((char*)handle + size); /* seek to top of stack */ - *--p = (long long)crash; /* crash if entrypoint returns */ - *--p = (long long)entrypoint; /* start of function */ - *(long long*)handle = (long long)p; /* stack pointer */ + long long *p = (long long*)((char*)handle + size); /* seek to top of stack */ + *--p = (long long)crash; /* crash if entrypoint returns */ + *--p = (long long)entrypoint; /* start of function */ + *(long long*)handle = (long long)p; /* stack pointer */ } return handle; diff --git a/libco/arm.c b/libco/arm.c new file mode 100644 index 00000000..70dbdd1b --- /dev/null +++ b/libco/arm.c @@ -0,0 +1,71 @@ +/* + libco.arm (2015-06-18) + author: byuu + license: public domain +*/ + +#define LIBCO_C +#include "libco.h" + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +static thread_local unsigned long co_active_buffer[64]; +static thread_local cothread_t co_active_handle = 0; +static void (*co_swap)(cothread_t, cothread_t) = 0; + +static unsigned long co_swap_function[] = { + 0xe8a16ff0, /* stmia r1!, {r4-r11,sp,lr} */ + 0xe8b0aff0, /* ldmia r0!, {r4-r11,sp,pc} */ + 0xe12fff1e, /* bx lr */ +}; + +void co_init() { + unsigned long addr = (unsigned long)co_swap_function; + unsigned long base = addr - (addr % sysconf(_SC_PAGESIZE)); + unsigned long size = (addr - base) + sizeof co_swap_function; + mprotect((void*)base, size, PROT_READ | PROT_WRITE | PROT_EXEC); +} + +cothread_t co_active() { + if(!co_active_handle) co_active_handle = &co_active_buffer; + return co_active_handle; +} + +cothread_t co_create(unsigned int size, void (*entrypoint)(void)) { + unsigned long* handle = 0; + if(!co_swap) { + co_init(); + co_swap = (void (*)(cothread_t, cothread_t))co_swap_function; + } + if(!co_active_handle) co_active_handle = &co_active_buffer; + size += 256; + size &= ~15; + + if(handle = (unsigned long*)malloc(size)) { + unsigned long* p = (unsigned long*)((unsigned char*)handle + size); + handle[8] = (unsigned long)p; + handle[9] = (unsigned long)entrypoint; + } + + return handle; +} + +void co_delete(cothread_t handle) { + free(handle); +} + +void co_switch(cothread_t handle) { + cothread_t co_previous_handle = co_active_handle; + co_swap(co_active_handle = handle, co_previous_handle); +} + +#ifdef __cplusplus +} +#endif diff --git a/libco/fiber.c b/libco/fiber.c index 02ef5bc7..f57c0799 100644 --- a/libco/fiber.c +++ b/libco/fiber.c @@ -6,9 +6,9 @@ #define LIBCO_C #include "libco.h" + #define WINVER 0x0400 #define _WIN32_WINNT 0x0400 -#define WIN32_LEAN_AND_MEAN #include #ifdef __cplusplus diff --git a/libco/libco.c b/libco/libco.c index 55676263..c48ffd97 100644 --- a/libco/libco.c +++ b/libco/libco.c @@ -1,23 +1,30 @@ /* libco - auto-selection module license: public domain */ -#if defined(__GNUC__) && defined(__i386__) - #include "x86.c" -#elif defined(__GNUC__) && defined(__amd64__) - #include "amd64.c" -#elif defined(__GNUC__) && defined(_ARCH_PPC) - #include "ppc.c" -#elif defined(__GNUC__) - #include "sjlj.c" -#elif defined(_MSC_VER) && defined(_M_IX86) - #include "x86.c" -#elif defined(_MSC_VER) && defined(_M_AMD64) - #include "amd64.c" +#if defined(__clang__) || defined(__GNUC__) + #if defined(__i386__) + #include "x86.c" + #elif defined(__amd64__) + #include "amd64.c" + #elif defined(__arm__) + #include "arm.c" + #elif defined(_ARCH_PPC) + #include "ppc.c" + #elif defined(_WIN32) + #include "fiber.c" + #else + #include "sjlj.c" + #endif #elif defined(_MSC_VER) - #include "fiber.c" + #if defined(_M_IX86) + #include "x86.c" + #elif defined(_M_AMD64) + #include "amd64.c" + #else + #include "fiber.c" + #endif #else #error "libco: unsupported processor, compiler or operating system" #endif diff --git a/libco/libco.h b/libco/libco.h index deb954fb..1851696e 100644 --- a/libco/libco.h +++ b/libco/libco.h @@ -1,6 +1,7 @@ /* libco - version: 0.16 (2010-12-24) + version: 0.17 (2015-06-18) + author: byuu license: public domain */ diff --git a/libco/ppc.c b/libco/ppc.c index a6028fdb..d509cd9e 100644 --- a/libco/ppc.c +++ b/libco/ppc.c @@ -9,6 +9,7 @@ floating-point and AltiVec save/restore */ #define LIBCO_C #include "libco.h" + #include #include #include diff --git a/libco/sjlj.c b/libco/sjlj.c index 8b72b614..9203efe7 100644 --- a/libco/sjlj.c +++ b/libco/sjlj.c @@ -13,6 +13,7 @@ #define LIBCO_C #include "libco.h" + #include #include #include diff --git a/libco/x86.c b/libco/x86.c index d8f820b0..44bbe4b8 100644 --- a/libco/x86.c +++ b/libco/x86.c @@ -6,6 +6,7 @@ #define LIBCO_C #include "libco.h" + #include #include @@ -13,10 +14,10 @@ extern "C" { #endif -#if defined(_MSC_VER) - #define fastcall __fastcall -#elif defined(__GNUC__) +#if defined(__clang__) || defined(__GNUC__) #define fastcall __attribute__((fastcall)) +#elif defined(_MSC_VER) + #define fastcall __fastcall #else #error "libco: please define fastcall macro" #endif @@ -25,10 +26,20 @@ static thread_local long co_active_buffer[64]; static thread_local cothread_t co_active_handle = 0; static void (fastcall *co_swap)(cothread_t, cothread_t) = 0; -//ABI: fastcall +/* ABI: fastcall */ static unsigned char co_swap_function[] = { - 0x89, 0x22, 0x8B, 0x21, 0x58, 0x89, 0x6A, 0x04, 0x89, 0x72, 0x08, 0x89, 0x7A, 0x0C, 0x89, 0x5A, - 0x10, 0x8B, 0x69, 0x04, 0x8B, 0x71, 0x08, 0x8B, 0x79, 0x0C, 0x8B, 0x59, 0x10, 0xFF, 0xE0, + 0x89, 0x22, /* mov [edx],esp */ + 0x8b, 0x21, /* mov esp,[ecx] */ + 0x58, /* pop eax */ + 0x89, 0x6a, 0x04, /* mov [edx+ 4],ebp */ + 0x89, 0x72, 0x08, /* mov [edx+ 8],esi */ + 0x89, 0x7a, 0x0c, /* mov [edx+12],edi */ + 0x89, 0x5a, 0x10, /* mov [edx+16],ebx */ + 0x8b, 0x69, 0x04, /* mov ebp,[ecx+ 4] */ + 0x8b, 0x71, 0x08, /* mov esi,[ecx+ 8] */ + 0x8b, 0x79, 0x0c, /* mov edi,[ecx+12] */ + 0x8b, 0x59, 0x10, /* mov ebx,[ecx+16] */ + 0xff, 0xe0, /* jmp eax */ }; #ifdef _WIN32 @@ -51,7 +62,7 @@ static unsigned char co_swap_function[] = { #endif static void crash() { - assert(0); /* called only if cothread_t entrypoint returns */ + assert(0); /* called only if cothread_t entrypoint returns */ } cothread_t co_active() { @@ -66,14 +77,14 @@ cothread_t co_create(unsigned int size, void (*entrypoint)(void)) { co_swap = (void (fastcall*)(cothread_t, cothread_t))co_swap_function; } if(!co_active_handle) co_active_handle = &co_active_buffer; - size += 256; /* allocate additional space for storage */ - size &= ~15; /* align stack to 16-byte boundary */ + size += 256; /* allocate additional space for storage */ + size &= ~15; /* align stack to 16-byte boundary */ if(handle = (cothread_t)malloc(size)) { - long *p = (long*)((char*)handle + size); /* seek to top of stack */ - *--p = (long)crash; /* crash if entrypoint returns */ - *--p = (long)entrypoint; /* start of function */ - *(long*)handle = (long)p; /* stack pointer */ + long *p = (long*)((char*)handle + size); /* seek to top of stack */ + *--p = (long)crash; /* crash if entrypoint returns */ + *--p = (long)entrypoint; /* start of function */ + *(long*)handle = (long)p; /* stack pointer */ } return handle; diff --git a/nall/dl.hpp b/nall/dl.hpp index baf7e70e..289e3a9f 100644 --- a/nall/dl.hpp +++ b/nall/dl.hpp @@ -8,11 +8,11 @@ #include #include -#if defined(PLATFORM_XORG) || defined(PLATFORM_MACOSX) - #include -#elif defined(PLATFORM_WINDOWS) +#if defined(PLATFORM_WINDOWS) #include #include +#else + #include #endif namespace nall { @@ -35,7 +35,7 @@ private: uintptr_t handle = 0; }; -#if defined(PLATFORM_XORG) +#if defined(PLATFORM_LINUX) || defined(PLATFORM_BSD) inline bool library::open(const string& name, const string& path) { if(handle) close(); if(path) handle = (uintptr_t)dlopen(string(path, "lib", name, ".so"), RTLD_LAZY); diff --git a/nall/intrinsics.hpp b/nall/intrinsics.hpp index 90bd44e1..6c55f816 100644 --- a/nall/intrinsics.hpp +++ b/nall/intrinsics.hpp @@ -2,19 +2,21 @@ #define NALL_INTRINSICS_HPP namespace nall { + struct Intrinsics { + enum class Compiler : unsigned { Clang, GCC, VisualCPP, Unknown }; + enum class Platform : unsigned { Windows, MacOSX, Linux, BSD, Unknown }; + enum class API : unsigned { Windows, Posix, Unknown }; + enum class Display : unsigned { Windows, Quartz, Xorg, Unknown }; + enum class Processor : unsigned { x86, amd64, ARM, PPC32, PPC64, Unknown }; + enum class Endian : unsigned { LSB, MSB, Unknown }; -struct Intrinsics { - enum class Compiler : unsigned { Clang, GCC, CL, Unknown }; - enum class Platform : unsigned { Windows, MacOSX, Linux, BSD, Unknown }; - enum class Architecture : unsigned { x86, amd64, Unknown }; - enum class Endian : unsigned { LSB, MSB, Unknown }; - - static inline Compiler compiler(); - static inline Platform platform(); - static inline Architecture architecture(); - static inline Endian endian(); -}; - + static inline auto compiler() -> Compiler; + static inline auto platform() -> Platform; + static inline auto api() -> API; + static inline auto display() -> Display; + static inline auto processor() -> Processor; + static inline auto endian() -> Endian; + }; } /* Compiler detection */ @@ -23,7 +25,7 @@ namespace nall { #if defined(__clang__) #define COMPILER_CLANG - Intrinsics::Compiler Intrinsics::compiler() { return Intrinsics::Compiler::Clang; } + auto Intrinsics::compiler() -> Compiler { return Compiler::Clang; } #pragma clang diagnostic ignored "-Wunknown-pragmas" #pragma clang diagnostic ignored "-Wempty-body" @@ -34,16 +36,16 @@ namespace nall { #pragma clang diagnostic ignored "-Wtautological-compare" #elif defined(__GNUC__) #define COMPILER_GCC - Intrinsics::Compiler Intrinsics::compiler() { return Intrinsics::Compiler::GCC; } + auto Intrinsics::compiler() -> Compiler { return Compiler::GCC; } #elif defined(_MSC_VER) - #define COMPILER_CL - Intrinsics::Compiler Intrinsics::compiler() { return Intrinsics::Compiler::CL; } + #define COMPILER_VISUALCPP + auto Intrinsics::compiler() -> Compiler { return Compiler::VisualCPP; } #pragma warning(disable:4996) //disable libc "deprecation" warnings #else #warning "unable to detect compiler" #define COMPILER_UNKNOWN - Intrinsics::Compiler Intrinsics::compiler() { return Intrinsics::Compiler::Unknown; } + auto Intrinsics::compiler() -> Compiler { return Compiler::Unknown; } #endif } @@ -54,31 +56,44 @@ namespace nall { #if defined(_WIN32) #define PLATFORM_WINDOWS - Intrinsics::Platform Intrinsics::platform() { return Intrinsics::Platform::Windows; } + #define API_WINDOWS + #define DISPLAY_WINDOW + auto Intrinsics::platform() -> Platform { return Platform::Windows; } + auto Intrinsics::api() -> API { return API::Windows; } + auto Intrinsics::display() -> Display { return Display::Windows; } #elif defined(__APPLE__) - #define PLATFORM_POSIX #define PLATFORM_MACOSX - Intrinsics::Platform Intrinsics::platform() { return Intrinsics::Platform::MacOSX; } + #define API_POSIX + #define DISPLAY_QUARTZ + auto Intrinsics::platform() -> Platform { return Platform::MacOSX; } + auto Intrinsics::api() -> API { return API::Posix; } + auto Intrinsics::display() -> Display { return Display::Quartz; } #elif defined(linux) || defined(__linux__) - #define PLATFORM_POSIX #define PLATFORM_LINUX - #define PLATFORM_XORG - Intrinsics::Platform Intrinsics::platform() { return Intrinsics::Platform::Linux; } + #define API_POSIX + #define DISPLAY_XORG + auto Intrinsics::platform() -> Platform { return Platform::Linux; } + auto Intrinsics::api() -> API { return API::Posix; } + auto Intrinsics::display() -> Display { return Display::Xorg; } #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__) - #define PLATFORM_POSIX #define PLATFORM_BSD - #define PLATFORM_XORG - Intrinsics::Platform Intrinsics::platform() { return Intrinsics::Platform::BSD; } + #define API_POSIX + #define DISPLAY_XORG + auto Intrinsics::platform() -> Platform { return Platform::BSD; } + auto Intrinsics::api() -> API { return API::Posix; } + auto Intrinsics::display() -> Display { return Display::Xorg; } #else #warning "unable to detect platform" #define PLATFORM_UNKNOWN - Intrinsics::Platform Intrinsics::platform() { return Intrinsics::Platform::Unknown; } + #define API_UNKNOWN + #define DISPLAY_UNKNOWN + auto Intrinsics::platform() -> Platform { return Platform::Unknown; } + auto Intrinsics::api() -> API { return API::Unknown; } + auto Intrinsics::display() -> Display { return Display::Unknown; } #endif } -/* Architecture Detection */ - #if defined(PLATFORM_MACOSX) #include #elif defined(PLATFORM_LINUX) @@ -87,18 +102,29 @@ namespace nall { #include #endif +/* Processor Detection */ + namespace nall { #if defined(__i386__) || defined(_M_IX86) - #define ARCH_X86 - Intrinsics::Architecture Intrinsics::architecture() { return Intrinsics::Architecture::x86; } + #define PROCESSOR_X86 + auto Intrinsics::processor() -> Processor { return Processor::x86; } #elif defined(__amd64__) || defined(_M_AMD64) - #define ARCH_AMD64 - Intrinsics::Architecture Intrinsics::architecture() { return Intrinsics::Architecture::amd64; } + #define PROCESSOR_AMD64 + auto Intrinsics::processor() -> Processor { return Processor::amd64; } +#elif defined(__arm__) + #define PROCESSOR_ARM + auto Intrinsics::processor() -> Processor { return Processor::ARM; } +#elif defined(__ppc64__) || defined(_ARCH_PPC64) + #define PROCESSOR_PPC64 + auto Intrinsics::processor() -> Processor { return Processor::PPC64; } +#elif defined(__ppc__) || defined(_ARCH_PPC) || defined(_M_PPC) + #define PROCESSOR_PPC32 + auto Intrinsics::processor() -> Processor { return Processor::PPC32; } #else - #warning "unable to detect architecture" - #define ARCH_UNKNOWN - Intrinsics::Architecture Intrinsics::architecture() { return Intrinsics::Architecture::Unknown; } + #warning "unable to detect processor" + #define PROCESSOR_UNKNOWN + auto Intrinsics::processor() -> Processor { return Processor::Unknown; } #endif } @@ -109,14 +135,14 @@ namespace nall { #if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN) || defined(__LITTLE_ENDIAN__) || defined(__i386__) || defined(__amd64__) || defined(_M_IX86) || defined(_M_AMD64) #define ENDIAN_LSB - Intrinsics::Endian Intrinsics::endian() { return Intrinsics::Endian::LSB; } + auto Intrinsics::endian() -> Endian { return Endian::LSB; } #elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && __BYTE_ORDER == __BIG_ENDIAN) || defined(__BIG_ENDIAN__) || defined(__powerpc__) || defined(_M_PPC) #define ENDIAN_MSB - Intrinsics::Endian Intrinsics::endian() { return Intrinsics::Endian::MSB; } + auto Intrinsics::endian() -> Endian { return Endian::MSB; } #else #warning "unable to detect endian" #define ENDIAN_UNKNOWN - Intrinsics::Endian Intrinsics::endian() { return Intrinsics::Endian::Unknown; } + auto Intrinsics::endian() -> Endian { return Endian::Unknown; } #endif } diff --git a/nall/invoke.hpp b/nall/invoke.hpp index a697fbe8..2651ab8f 100644 --- a/nall/invoke.hpp +++ b/nall/invoke.hpp @@ -1,7 +1,7 @@ #ifndef NALL_INVOKE_HPP #define NALL_INVOKE_HPP -//void invoke(const string &name, const string& args...); +//auto invoke(const string &name, const string& args...) -> void; //if a program is specified, it is executed with the arguments provided //if a file is specified, the file is opened using the program associated with said file type //if a folder is specified, the folder is opened using the associated file explorer @@ -20,16 +20,16 @@ namespace nall { #if defined(PLATFORM_WINDOWS) -template inline void invoke(const string& name, Args&&... args) { +template inline auto invoke(const string& name, Args&&... args) -> void { lstring argl(std::forward(args)...); for(auto& arg : argl) if(arg.find(" ")) arg = {"\"", arg, "\""}; string arguments = argl.merge(" "); ShellExecuteW(NULL, NULL, utf16_t(name), utf16_t(arguments), NULL, SW_SHOWNORMAL); } -#elif defined(PLATFORM_XORG) +#elif defined(PLATFORM_LINUX) || defined(PLATFORM_BSD) -template inline void invoke(const string& name, Args&&... args) { +template inline auto invoke(const string& name, Args&&... args) -> void { pid_t pid = fork(); if(pid == 0) { const char* argv[1 + sizeof...(args) + 1]; @@ -48,7 +48,7 @@ template inline void invoke(const string& name, Args&&... args #else -template inline void invoke(const string& name, Args&&... args) { +template inline auto invoke(const string& name, Args&&... args) -> void { } #endif diff --git a/nall/main.hpp b/nall/main.hpp index 98a433ab..70795dbf 100644 --- a/nall/main.hpp +++ b/nall/main.hpp @@ -10,7 +10,7 @@ namespace nall { auto main(int argc, char** argv) -> int { #if defined(PLATFORM_WINDOWS) CoInitialize(0); - WSAData wsaData = {0}; + WSAData wsaData{0}; WSAStartup(MAKEWORD(2, 2), &wsaData); utf8_args(argc, argv); #endif diff --git a/nall/nall.hpp b/nall/nall.hpp index 861b55d6..be7017f9 100644 --- a/nall/nall.hpp +++ b/nall/nall.hpp @@ -70,7 +70,7 @@ #include #endif -#if defined(PLATFORM_XORG) +#if defined(API_POSIX) #include #endif diff --git a/nall/platform.hpp b/nall/platform.hpp index d1139b14..550bbffe 100644 --- a/nall/platform.hpp +++ b/nall/platform.hpp @@ -54,7 +54,7 @@ namespace Math { #include #endif -#if defined(COMPILER_CL) +#if defined(COMPILER_VISUALCPP) #define va_copy(dest, src) ((dest) = (src)) #endif @@ -101,7 +101,7 @@ namespace Math { #define neverinline __attribute__((noinline)) #define alwaysinline inline __attribute__((always_inline)) #define deprecated __attribute__((deprecated)) -#elif defined(COMPILER_CL) +#elif defined(COMPILER_VISUALCPP) #define neverinline __declspec(noinline) #define alwaysinline inline __forceinline #define deprecated __declspec(deprecated) diff --git a/nall/serial.hpp b/nall/serial.hpp index 63f9f0b5..14d2b321 100644 --- a/nall/serial.hpp +++ b/nall/serial.hpp @@ -5,8 +5,8 @@ #include #include -#if !defined(PLATFORM_XORG) && !defined(PLATFORM_MACOSX) - #error "nall/serial: unsupported platform" +#if !defined(API_POSIX) + #error "nall/serial: unsupported system" #endif #include diff --git a/nall/service.hpp b/nall/service.hpp index c0f1774c..86bd2a75 100644 --- a/nall/service.hpp +++ b/nall/service.hpp @@ -5,11 +5,11 @@ #include -#if defined(PLATFORM_POSIX) +#if defined(API_POSIX) #include #endif -#if defined(PLATFORM_WINDOWS) +#if defined(API_WINDOWS) #include #endif diff --git a/nall/shared-memory.hpp b/nall/shared-memory.hpp index f94566cc..f973a764 100644 --- a/nall/shared-memory.hpp +++ b/nall/shared-memory.hpp @@ -4,11 +4,11 @@ #include #include -#if defined(PLATFORM_POSIX) +#if defined(API_POSIX) #include #endif -#if defined(PLATFORM_WINDOWS) +#if defined(API_WINDOWS) #include #endif diff --git a/nall/thread.hpp b/nall/thread.hpp index e07339c6..ecbf7700 100644 --- a/nall/thread.hpp +++ b/nall/thread.hpp @@ -11,7 +11,7 @@ #include #include -#if defined(PLATFORM_BSD) || defined(PLATFORM_LINUX) || defined(PLATFORM_MACOSX) +#if defined(API_POSIX) #include @@ -69,7 +69,7 @@ auto thread::exit() -> void { } -#elif defined(PLATFORM_WINDOWS) +#elif defined(API_WINDOWS) namespace nall { diff --git a/processor/r65816/algorithms.cpp b/processor/r65816/algorithms.cpp index e100782e..385f07b2 100644 --- a/processor/r65816/algorithms.cpp +++ b/processor/r65816/algorithms.cpp @@ -1,4 +1,4 @@ -inline void R65816::op_adc_b() { +auto R65816::op_adc_b() { int result; if(!regs.p.d) { @@ -19,7 +19,7 @@ inline void R65816::op_adc_b() { regs.a.l = result; } -inline void R65816::op_adc_w() { +auto R65816::op_adc_w() { int result; if(!regs.p.d) { @@ -46,133 +46,133 @@ inline void R65816::op_adc_w() { regs.a.w = result; } -inline void R65816::op_and_b() { +auto R65816::op_and_b() { regs.a.l &= rd.l; regs.p.n = regs.a.l & 0x80; regs.p.z = regs.a.l == 0; } -inline void R65816::op_and_w() { +auto R65816::op_and_w() { regs.a.w &= rd.w; regs.p.n = regs.a.w & 0x8000; regs.p.z = regs.a.w == 0; } -inline void R65816::op_bit_b() { +auto R65816::op_bit_b() { regs.p.n = rd.l & 0x80; regs.p.v = rd.l & 0x40; regs.p.z = (rd.l & regs.a.l) == 0; } -inline void R65816::op_bit_w() { +auto R65816::op_bit_w() { regs.p.n = rd.w & 0x8000; regs.p.v = rd.w & 0x4000; regs.p.z = (rd.w & regs.a.w) == 0; } -inline void R65816::op_cmp_b() { +auto R65816::op_cmp_b() { int r = regs.a.l - rd.l; regs.p.n = r & 0x80; regs.p.z = (uint8)r == 0; regs.p.c = r >= 0; } -inline void R65816::op_cmp_w() { +auto R65816::op_cmp_w() { int r = regs.a.w - rd.w; regs.p.n = r & 0x8000; regs.p.z = (uint16)r == 0; regs.p.c = r >= 0; } -inline void R65816::op_cpx_b() { +auto R65816::op_cpx_b() { int r = regs.x.l - rd.l; regs.p.n = r & 0x80; regs.p.z = (uint8)r == 0; regs.p.c = r >= 0; } -inline void R65816::op_cpx_w() { +auto R65816::op_cpx_w() { int r = regs.x.w - rd.w; regs.p.n = r & 0x8000; regs.p.z = (uint16)r == 0; regs.p.c = r >= 0; } -inline void R65816::op_cpy_b() { +auto R65816::op_cpy_b() { int r = regs.y.l - rd.l; regs.p.n = r & 0x80; regs.p.z = (uint8)r == 0; regs.p.c = r >= 0; } -inline void R65816::op_cpy_w() { +auto R65816::op_cpy_w() { int r = regs.y.w - rd.w; regs.p.n = r & 0x8000; regs.p.z = (uint16)r == 0; regs.p.c = r >= 0; } -inline void R65816::op_eor_b() { +auto R65816::op_eor_b() { regs.a.l ^= rd.l; regs.p.n = regs.a.l & 0x80; regs.p.z = regs.a.l == 0; } -inline void R65816::op_eor_w() { +auto R65816::op_eor_w() { regs.a.w ^= rd.w; regs.p.n = regs.a.w & 0x8000; regs.p.z = regs.a.w == 0; } -inline void R65816::op_lda_b() { +auto R65816::op_lda_b() { regs.a.l = rd.l; regs.p.n = regs.a.l & 0x80; regs.p.z = regs.a.l == 0; } -inline void R65816::op_lda_w() { +auto R65816::op_lda_w() { regs.a.w = rd.w; regs.p.n = regs.a.w & 0x8000; regs.p.z = regs.a.w == 0; } -inline void R65816::op_ldx_b() { +auto R65816::op_ldx_b() { regs.x.l = rd.l; regs.p.n = regs.x.l & 0x80; regs.p.z = regs.x.l == 0; } -inline void R65816::op_ldx_w() { +auto R65816::op_ldx_w() { regs.x.w = rd.w; regs.p.n = regs.x.w & 0x8000; regs.p.z = regs.x.w == 0; } -inline void R65816::op_ldy_b() { +auto R65816::op_ldy_b() { regs.y.l = rd.l; regs.p.n = regs.y.l & 0x80; regs.p.z = regs.y.l == 0; } -inline void R65816::op_ldy_w() { +auto R65816::op_ldy_w() { regs.y.w = rd.w; regs.p.n = regs.y.w & 0x8000; regs.p.z = regs.y.w == 0; } -inline void R65816::op_ora_b() { +auto R65816::op_ora_b() { regs.a.l |= rd.l; regs.p.n = regs.a.l & 0x80; regs.p.z = regs.a.l == 0; } -inline void R65816::op_ora_w() { +auto R65816::op_ora_w() { regs.a.w |= rd.w; regs.p.n = regs.a.w & 0x8000; regs.p.z = regs.a.w == 0; } -inline void R65816::op_sbc_b() { +auto R65816::op_sbc_b() { int result; rd.l ^= 0xff; @@ -194,7 +194,7 @@ inline void R65816::op_sbc_b() { regs.a.l = result; } -inline void R65816::op_sbc_w() { +auto R65816::op_sbc_w() { int result; rd.w ^= 0xffff; @@ -222,59 +222,59 @@ inline void R65816::op_sbc_w() { regs.a.w = result; } -inline void R65816::op_inc_b() { +auto R65816::op_inc_b() { rd.l++; regs.p.n = rd.l & 0x80; regs.p.z = rd.l == 0; } -inline void R65816::op_inc_w() { +auto R65816::op_inc_w() { rd.w++; regs.p.n = rd.w & 0x8000; regs.p.z = rd.w == 0; } -inline void R65816::op_dec_b() { +auto R65816::op_dec_b() { rd.l--; regs.p.n = rd.l & 0x80; regs.p.z = rd.l == 0; } -inline void R65816::op_dec_w() { +auto R65816::op_dec_w() { rd.w--; regs.p.n = rd.w & 0x8000; regs.p.z = rd.w == 0; } -inline void R65816::op_asl_b() { +auto R65816::op_asl_b() { regs.p.c = rd.l & 0x80; rd.l <<= 1; regs.p.n = rd.l & 0x80; regs.p.z = rd.l == 0; } -inline void R65816::op_asl_w() { +auto R65816::op_asl_w() { regs.p.c = rd.w & 0x8000; rd.w <<= 1; regs.p.n = rd.w & 0x8000; regs.p.z = rd.w == 0; } -inline void R65816::op_lsr_b() { +auto R65816::op_lsr_b() { regs.p.c = rd.l & 1; rd.l >>= 1; regs.p.n = rd.l & 0x80; regs.p.z = rd.l == 0; } -inline void R65816::op_lsr_w() { +auto R65816::op_lsr_w() { regs.p.c = rd.w & 1; rd.w >>= 1; regs.p.n = rd.w & 0x8000; regs.p.z = rd.w == 0; } -inline void R65816::op_rol_b() { +auto R65816::op_rol_b() { unsigned carry = (unsigned)regs.p.c; regs.p.c = rd.l & 0x80; rd.l = (rd.l << 1) | carry; @@ -282,7 +282,7 @@ inline void R65816::op_rol_b() { regs.p.z = rd.l == 0; } -inline void R65816::op_rol_w() { +auto R65816::op_rol_w() { unsigned carry = (unsigned)regs.p.c; regs.p.c = rd.w & 0x8000; rd.w = (rd.w << 1) | carry; @@ -290,7 +290,7 @@ inline void R65816::op_rol_w() { regs.p.z = rd.w == 0; } -inline void R65816::op_ror_b() { +auto R65816::op_ror_b() { unsigned carry = (unsigned)regs.p.c << 7; regs.p.c = rd.l & 1; rd.l = carry | (rd.l >> 1); @@ -298,7 +298,7 @@ inline void R65816::op_ror_b() { regs.p.z = rd.l == 0; } -inline void R65816::op_ror_w() { +auto R65816::op_ror_w() { unsigned carry = (unsigned)regs.p.c << 15; regs.p.c = rd.w & 1; rd.w = carry | (rd.w >> 1); @@ -306,22 +306,22 @@ inline void R65816::op_ror_w() { regs.p.z = rd.w == 0; } -inline void R65816::op_trb_b() { +auto R65816::op_trb_b() { regs.p.z = (rd.l & regs.a.l) == 0; rd.l &= ~regs.a.l; } -inline void R65816::op_trb_w() { +auto R65816::op_trb_w() { regs.p.z = (rd.w & regs.a.w) == 0; rd.w &= ~regs.a.w; } -inline void R65816::op_tsb_b() { +auto R65816::op_tsb_b() { regs.p.z = (rd.l & regs.a.l) == 0; rd.l |= regs.a.l; } -inline void R65816::op_tsb_w() { +auto R65816::op_tsb_w() { regs.p.z = (rd.w & regs.a.w) == 0; rd.w |= regs.a.w; } diff --git a/processor/r65816/disassembler.cpp b/processor/r65816/disassembler.cpp index f164ee19..c86caa2d 100644 --- a/processor/r65816/disassembler.cpp +++ b/processor/r65816/disassembler.cpp @@ -1,4 +1,4 @@ -uint8 R65816::dreadb(uint32 addr) { +auto R65816::dreadb(uint32 addr) -> uint8 { if((addr & 0x40ffff) >= 0x2000 && (addr & 0x40ffff) <= 0x5fff) { //$[00-3f|80-bf]:[2000-5fff] //do not read MMIO registers within debugger @@ -7,14 +7,14 @@ uint8 R65816::dreadb(uint32 addr) { return disassembler_read(addr); } -uint16 R65816::dreadw(uint32 addr) { +auto R65816::dreadw(uint32 addr) -> uint16 { uint16 r; r = dreadb((addr + 0) & 0xffffff) << 0; r |= dreadb((addr + 1) & 0xffffff) << 8; return r; } -uint32 R65816::dreadl(uint32 addr) { +auto R65816::dreadl(uint32 addr) -> uint32 { uint32 r; r = dreadb((addr + 0) & 0xffffff) << 0; r |= dreadb((addr + 1) & 0xffffff) << 8; @@ -22,7 +22,7 @@ uint32 R65816::dreadl(uint32 addr) { return r; } -uint32 R65816::decode(uint8 offset_type, uint32 addr) { +auto R65816::decode(uint8 offset_type, uint32 addr) -> uint32 { uint32 r = 0; switch(offset_type) { @@ -102,11 +102,11 @@ uint32 R65816::decode(uint8 offset_type, uint32 addr) { return(r & 0xffffff); } -void R65816::disassemble_opcode(char* output) { +auto R65816::disassemble_opcode(char* output) -> void { return disassemble_opcode(output, regs.pc.d, regs.e, regs.p.m, regs.p.x); } -void R65816::disassemble_opcode(char* output, uint32 addr, bool e, bool m, bool x) { +auto R65816::disassemble_opcode(char* output, uint32 addr, bool e, bool m, bool x) -> void { static reg24_t pc; char t[256]; char* s = output; diff --git a/processor/r65816/disassembler.hpp b/processor/r65816/disassembler.hpp index 7b5d9c2c..4704456f 100644 --- a/processor/r65816/disassembler.hpp +++ b/processor/r65816/disassembler.hpp @@ -22,9 +22,9 @@ enum : unsigned { OPTYPE_RELW, //relw }; -void disassemble_opcode(char* output); -void disassemble_opcode(char* output, uint32 addr, bool e, bool m, bool x); -uint8 dreadb(uint32 addr); -uint16 dreadw(uint32 addr); -uint32 dreadl(uint32 addr); -uint32 decode(uint8 offset_type, uint32 addr); +auto disassemble_opcode(char* output) -> void; +auto disassemble_opcode(char* output, uint32 addr, bool e, bool m, bool x) -> void; +auto dreadb(uint32 addr) -> uint8; +auto dreadw(uint32 addr) -> uint16; +auto dreadl(uint32 addr) -> uint32; +auto decode(uint8 offset_type, uint32 addr) -> uint32; diff --git a/processor/r65816/memory.hpp b/processor/r65816/memory.hpp index 590b8922..68cf6b9c 100644 --- a/processor/r65816/memory.hpp +++ b/processor/r65816/memory.hpp @@ -1,33 +1,33 @@ -alwaysinline uint8 op_readpc() { +alwaysinline auto op_readpc() -> uint8 { return op_read((regs.pc.b << 16) + regs.pc.w++); } -alwaysinline uint8 op_readstack() { +alwaysinline auto op_readstack() -> uint8 { regs.e ? regs.s.l++ : regs.s.w++; return op_read(regs.s.w); } -alwaysinline uint8 op_readstackn() { +alwaysinline auto op_readstackn() -> uint8 { return op_read(++regs.s.w); } -alwaysinline uint8 op_readaddr(uint32 addr) { +alwaysinline auto op_readaddr(uint32 addr) -> uint8 { return op_read(addr & 0xffff); } -alwaysinline uint8 op_readlong(uint32 addr) { +alwaysinline auto op_readlong(uint32 addr) -> uint8 { return op_read(addr & 0xffffff); } -alwaysinline uint8 op_readdbr(uint32 addr) { +alwaysinline auto op_readdbr(uint32 addr) -> uint8 { return op_read(((regs.db << 16) + addr) & 0xffffff); } -alwaysinline uint8 op_readpbr(uint32 addr) { +alwaysinline auto op_readpbr(uint32 addr) -> uint8 { return op_read((regs.pc.b << 16) + (addr & 0xffff)); } -alwaysinline uint8 op_readdp(uint32 addr) { +alwaysinline auto op_readdp(uint32 addr) -> uint8 { if(regs.e && regs.d.l == 0x00) { return op_read((regs.d & 0xff00) + ((regs.d + (addr & 0xffff)) & 0xff)); } else { @@ -35,36 +35,36 @@ alwaysinline uint8 op_readdp(uint32 addr) { } } -alwaysinline uint8 op_readsp(uint32 addr) { +alwaysinline auto op_readsp(uint32 addr) -> uint8 { return op_read((regs.s + (addr & 0xffff)) & 0xffff); } -alwaysinline void op_writestack(uint8 data) { +alwaysinline auto op_writestack(uint8 data) -> void { op_write(regs.s.w, data); regs.e ? regs.s.l-- : regs.s.w--; } -alwaysinline void op_writestackn(uint8 data) { +alwaysinline auto op_writestackn(uint8 data) -> void { op_write(regs.s.w--, data); } -alwaysinline void op_writeaddr(uint32 addr, uint8 data) { +alwaysinline auto op_writeaddr(uint32 addr, uint8 data) -> void { op_write(addr & 0xffff, data); } -alwaysinline void op_writelong(uint32 addr, uint8 data) { +alwaysinline auto op_writelong(uint32 addr, uint8 data) -> void { op_write(addr & 0xffffff, data); } -alwaysinline void op_writedbr(uint32 addr, uint8 data) { +alwaysinline auto op_writedbr(uint32 addr, uint8 data) -> void { op_write(((regs.db << 16) + addr) & 0xffffff, data); } -alwaysinline void op_writepbr(uint32 addr, uint8 data) { +alwaysinline auto op_writepbr(uint32 addr, uint8 data) -> void { op_write((regs.pc.b << 16) + (addr & 0xffff), data); } -alwaysinline void op_writedp(uint32 addr, uint8 data) { +alwaysinline auto op_writedp(uint32 addr, uint8 data) -> void { if(regs.e && regs.d.l == 0x00) { op_write((regs.d & 0xff00) + ((regs.d + (addr & 0xffff)) & 0xff), data); } else { @@ -72,6 +72,6 @@ alwaysinline void op_writedp(uint32 addr, uint8 data) { } } -alwaysinline void op_writesp(uint32 addr, uint8 data) { +alwaysinline auto op_writesp(uint32 addr, uint8 data) -> void { op_write((regs.s + (addr & 0xffff)) & 0xffff, data); } diff --git a/processor/r65816/opcode_misc.cpp b/processor/r65816/opcode_misc.cpp index 7d17b6fb..d1306f73 100644 --- a/processor/r65816/opcode_misc.cpp +++ b/processor/r65816/opcode_misc.cpp @@ -1,12 +1,12 @@ -void R65816::op_nop() { +auto R65816::op_nop() { L op_io_irq(); } -void R65816::op_wdm() { +auto R65816::op_wdm() { L op_readpc(); } -void R65816::op_xba() { +auto R65816::op_xba() { op_io(); L op_io(); regs.a.l ^= regs.a.h; @@ -16,7 +16,7 @@ L op_io(); regs.p.z = (regs.a.l == 0); } -template void R65816::op_move_b() { +auto R65816::op_move_b(signed adjust) { dp = op_readpc(); sp = op_readpc(); regs.db = dp; @@ -29,7 +29,7 @@ L op_io(); if(regs.a.w--) regs.pc.w -= 3; } -template void R65816::op_move_w() { +auto R65816::op_move_w(signed adjust) { dp = op_readpc(); sp = op_readpc(); regs.db = dp; @@ -42,40 +42,40 @@ L op_io(); if(regs.a.w--) regs.pc.w -= 3; } -template void R65816::op_interrupt_e() { +auto R65816::op_interrupt_e(uint16 vector) { op_readpc(); op_writestack(regs.pc.h); op_writestack(regs.pc.l); op_writestack(regs.p); - rd.l = op_readlong(vectorE + 0); + rd.l = op_readlong(vector + 0); regs.pc.b = 0; regs.p.i = 1; regs.p.d = 0; -L rd.h = op_readlong(vectorE + 1); +L rd.h = op_readlong(vector + 1); regs.pc.w = rd.w; } -template void R65816::op_interrupt_n() { +auto R65816::op_interrupt_n(uint16 vector) { op_readpc(); op_writestack(regs.pc.b); op_writestack(regs.pc.h); op_writestack(regs.pc.l); op_writestack(regs.p); - rd.l = op_readlong(vectorN + 0); + rd.l = op_readlong(vector + 0); regs.pc.b = 0x00; regs.p.i = 1; regs.p.d = 0; -L rd.h = op_readlong(vectorN + 1); +L rd.h = op_readlong(vector + 1); regs.pc.w = rd.w; } -void R65816::op_stp() { +auto R65816::op_stp() { while(regs.wai = true) { L op_io(); } } -void R65816::op_wai() { +auto R65816::op_wai() { regs.wai = true; while(regs.wai) { L op_io(); @@ -83,40 +83,36 @@ L op_io(); op_io(); } -void R65816::op_xce() { +auto R65816::op_xce() { L op_io_irq(); bool carry = regs.p.c; regs.p.c = regs.e; regs.e = carry; if(regs.e) { - regs.p |= 0x30; + regs.p.m = 1; + regs.p.x = 1; + regs.x.h = 0x00; + regs.y.h = 0x00; regs.s.h = 0x01; } - if(regs.p.x) { - regs.x.h = 0x00; - regs.y.h = 0x00; - } - update_table(); } -template void R65816::op_flag() { +auto R65816::op_flag(bool& flag, bool value) { L op_io_irq(); - regs.p = (regs.p & ~mask) | value; + flag = value; } -template void R65816::op_pflag_e() { +auto R65816::op_pflag_e(bool mode) { rd.l = op_readpc(); L op_io(); regs.p = (mode ? regs.p | rd.l : regs.p & ~rd.l); - regs.p |= 0x30; - if(regs.p.x) { - regs.x.h = 0x00; - regs.y.h = 0x00; - } - update_table(); + regs.p.m = 1; + regs.p.x = 1; + regs.x.h = 0x00; + regs.y.h = 0x00; } -template void R65816::op_pflag_n() { +auto R65816::op_pflag_n(bool mode) { rd.l = op_readpc(); L op_io(); regs.p = (mode ? regs.p | rd.l : regs.p & ~rd.l); @@ -124,114 +120,113 @@ L op_io(); regs.x.h = 0x00; regs.y.h = 0x00; } - update_table(); } -template void R65816::op_transfer_b() { +auto R65816::op_transfer_b(reg16_t& from, reg16_t& to) { L op_io_irq(); - regs.r[to].l = regs.r[from].l; - regs.p.n = (regs.r[to].l & 0x80); - regs.p.z = (regs.r[to].l == 0); + to.l = from.l; + regs.p.n = (to.l & 0x80); + regs.p.z = (to.l == 0); } -template void R65816::op_transfer_w() { +auto R65816::op_transfer_w(reg16_t& from, reg16_t& to) { L op_io_irq(); - regs.r[to].w = regs.r[from].w; - regs.p.n = (regs.r[to].w & 0x8000); - regs.p.z = (regs.r[to].w == 0); + to.w = from.w; + regs.p.n = (to.w & 0x8000); + regs.p.z = (to.w == 0); } -void R65816::op_tcs_e() { +auto R65816::op_tcs_e() { L op_io_irq(); regs.s.l = regs.a.l; } -void R65816::op_tcs_n() { +auto R65816::op_tcs_n() { L op_io_irq(); regs.s.w = regs.a.w; } -void R65816::op_tsx_b() { +auto R65816::op_tsx_b() { L op_io_irq(); regs.x.l = regs.s.l; regs.p.n = (regs.x.l & 0x80); regs.p.z = (regs.x.l == 0); } -void R65816::op_tsx_w() { +auto R65816::op_tsx_w() { L op_io_irq(); regs.x.w = regs.s.w; regs.p.n = (regs.x.w & 0x8000); regs.p.z = (regs.x.w == 0); } -void R65816::op_txs_e() { +auto R65816::op_txs_e() { L op_io_irq(); regs.s.l = regs.x.l; } -void R65816::op_txs_n() { +auto R65816::op_txs_n() { L op_io_irq(); regs.s.w = regs.x.w; } -template void R65816::op_push_b() { +auto R65816::op_push_b(reg16_t& reg) { op_io(); -L op_writestack(regs.r[n].l); +L op_writestack(reg.l); } -template void R65816::op_push_w() { +auto R65816::op_push_w(reg16_t& reg) { op_io(); - op_writestack(regs.r[n].h); -L op_writestack(regs.r[n].l); + op_writestack(reg.h); +L op_writestack(reg.l); } -void R65816::op_phd_e() { +auto R65816::op_phd_e() { op_io(); op_writestackn(regs.d.h); L op_writestackn(regs.d.l); regs.s.h = 0x01; } -void R65816::op_phd_n() { +auto R65816::op_phd_n() { op_io(); op_writestackn(regs.d.h); L op_writestackn(regs.d.l); } -void R65816::op_phb() { +auto R65816::op_phb() { op_io(); L op_writestack(regs.db); } -void R65816::op_phk() { +auto R65816::op_phk() { op_io(); L op_writestack(regs.pc.b); } -void R65816::op_php() { +auto R65816::op_php() { op_io(); L op_writestack(regs.p); } -template void R65816::op_pull_b() { +auto R65816::op_pull_b(reg16_t& reg) { op_io(); op_io(); -L regs.r[n].l = op_readstack(); - regs.p.n = (regs.r[n].l & 0x80); - regs.p.z = (regs.r[n].l == 0); +L reg.l = op_readstack(); + regs.p.n = (reg.l & 0x80); + regs.p.z = (reg.l == 0); } -template void R65816::op_pull_w() { +auto R65816::op_pull_w(reg16_t& reg) { op_io(); op_io(); - regs.r[n].l = op_readstack(); -L regs.r[n].h = op_readstack(); - regs.p.n = (regs.r[n].w & 0x8000); - regs.p.z = (regs.r[n].w == 0); + reg.l = op_readstack(); +L reg.h = op_readstack(); + regs.p.n = (reg.w & 0x8000); + regs.p.z = (reg.w == 0); } -void R65816::op_pld_e() { +auto R65816::op_pld_e() { op_io(); op_io(); regs.d.l = op_readstackn(); @@ -241,7 +236,7 @@ L regs.d.h = op_readstackn(); regs.s.h = 0x01; } -void R65816::op_pld_n() { +auto R65816::op_pld_n() { op_io(); op_io(); regs.d.l = op_readstackn(); @@ -250,7 +245,7 @@ L regs.d.h = op_readstackn(); regs.p.z = (regs.d.w == 0); } -void R65816::op_plb() { +auto R65816::op_plb() { op_io(); op_io(); L regs.db = op_readstack(); @@ -258,7 +253,7 @@ L regs.db = op_readstack(); regs.p.z = (regs.db == 0); } -void R65816::op_plp_e() { +auto R65816::op_plp_e() { op_io(); op_io(); L regs.p = op_readstack() | 0x30; @@ -266,10 +261,9 @@ L regs.p = op_readstack() | 0x30; regs.x.h = 0x00; regs.y.h = 0x00; } - update_table(); } -void R65816::op_plp_n() { +auto R65816::op_plp_n() { op_io(); op_io(); L regs.p = op_readstack(); @@ -277,10 +271,9 @@ L regs.p = op_readstack(); regs.x.h = 0x00; regs.y.h = 0x00; } - update_table(); } -void R65816::op_pea_e() { +auto R65816::op_pea_e() { aa.l = op_readpc(); aa.h = op_readpc(); op_writestackn(aa.h); @@ -288,14 +281,14 @@ L op_writestackn(aa.l); regs.s.h = 0x01; } -void R65816::op_pea_n() { +auto R65816::op_pea_n() { aa.l = op_readpc(); aa.h = op_readpc(); op_writestackn(aa.h); L op_writestackn(aa.l); } -void R65816::op_pei_e() { +auto R65816::op_pei_e() { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -305,7 +298,7 @@ L op_writestackn(aa.l); regs.s.h = 0x01; } -void R65816::op_pei_n() { +auto R65816::op_pei_n() { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -314,7 +307,7 @@ void R65816::op_pei_n() { L op_writestackn(aa.l); } -void R65816::op_per_e() { +auto R65816::op_per_e() { aa.l = op_readpc(); aa.h = op_readpc(); op_io(); @@ -324,7 +317,7 @@ L op_writestackn(rd.l); regs.s.h = 0x01; } -void R65816::op_per_n() { +auto R65816::op_per_n() { aa.l = op_readpc(); aa.h = op_readpc(); op_io(); diff --git a/processor/r65816/opcode_pc.cpp b/processor/r65816/opcode_pc.cpp index 22fccc8e..0e4b2767 100644 --- a/processor/r65816/opcode_pc.cpp +++ b/processor/r65816/opcode_pc.cpp @@ -1,5 +1,5 @@ -template void R65816::op_branch() { - if((bool)(regs.p & bit) != val) { +auto R65816::op_branch(bool flag, bool value) { + if(flag != value) { L rd.l = op_readpc(); } else { rd.l = op_readpc(); @@ -10,7 +10,7 @@ L op_io(); } } -void R65816::op_bra() { +auto R65816::op_bra() { rd.l = op_readpc(); aa.w = regs.pc.d + (int8)rd.l; op_io_cond6(aa.w); @@ -18,27 +18,27 @@ L op_io(); regs.pc.w = aa.w; } -void R65816::op_brl() { +auto R65816::op_brl() { rd.l = op_readpc(); rd.h = op_readpc(); L op_io(); regs.pc.w = regs.pc.d + (int16)rd.w; } -void R65816::op_jmp_addr() { +auto R65816::op_jmp_addr() { rd.l = op_readpc(); L rd.h = op_readpc(); regs.pc.w = rd.w; } -void R65816::op_jmp_long() { +auto R65816::op_jmp_long() { rd.l = op_readpc(); rd.h = op_readpc(); L rd.b = op_readpc(); regs.pc.d = rd.d & 0xffffff; } -void R65816::op_jmp_iaddr() { +auto R65816::op_jmp_iaddr() { aa.l = op_readpc(); aa.h = op_readpc(); rd.l = op_readaddr(aa.w + 0); @@ -46,7 +46,7 @@ L rd.h = op_readaddr(aa.w + 1); regs.pc.w = rd.w; } -void R65816::op_jmp_iaddrx() { +auto R65816::op_jmp_iaddrx() { aa.l = op_readpc(); aa.h = op_readpc(); op_io(); @@ -55,7 +55,7 @@ L rd.h = op_readpbr(aa.w + regs.x.w + 1); regs.pc.w = rd.w; } -void R65816::op_jmp_iladdr() { +auto R65816::op_jmp_iladdr() { aa.l = op_readpc(); aa.h = op_readpc(); rd.l = op_readaddr(aa.w + 0); @@ -64,7 +64,7 @@ L rd.b = op_readaddr(aa.w + 2); regs.pc.d = rd.d & 0xffffff; } -void R65816::op_jsr_addr() { +auto R65816::op_jsr_addr() { aa.l = op_readpc(); aa.h = op_readpc(); op_io(); @@ -74,7 +74,7 @@ L op_writestack(regs.pc.l); regs.pc.w = aa.w; } -void R65816::op_jsr_long_e() { +auto R65816::op_jsr_long_e() { aa.l = op_readpc(); aa.h = op_readpc(); op_writestackn(regs.pc.b); @@ -87,7 +87,7 @@ L op_writestackn(regs.pc.l); regs.s.h = 0x01; } -void R65816::op_jsr_long_n() { +auto R65816::op_jsr_long_n() { aa.l = op_readpc(); aa.h = op_readpc(); op_writestackn(regs.pc.b); @@ -99,7 +99,7 @@ L op_writestackn(regs.pc.l); regs.pc.d = aa.d & 0xffffff; } -void R65816::op_jsr_iaddrx_e() { +auto R65816::op_jsr_iaddrx_e() { aa.l = op_readpc(); op_writestackn(regs.pc.h); op_writestackn(regs.pc.l); @@ -111,7 +111,7 @@ L rd.h = op_readpbr(aa.w + regs.x.w + 1); regs.s.h = 0x01; } -void R65816::op_jsr_iaddrx_n() { +auto R65816::op_jsr_iaddrx_n() { aa.l = op_readpc(); op_writestackn(regs.pc.h); op_writestackn(regs.pc.l); @@ -122,7 +122,7 @@ L rd.h = op_readpbr(aa.w + regs.x.w + 1); regs.pc.w = rd.w; } -void R65816::op_rti_e() { +auto R65816::op_rti_e() { op_io(); op_io(); regs.p = op_readstack() | 0x30; @@ -131,7 +131,7 @@ L rd.h = op_readstack(); regs.pc.w = rd.w; } -void R65816::op_rti_n() { +auto R65816::op_rti_n() { op_io(); op_io(); regs.p = op_readstack(); @@ -143,10 +143,9 @@ void R65816::op_rti_n() { rd.h = op_readstack(); L rd.b = op_readstack(); regs.pc.d = rd.d & 0xffffff; - update_table(); } -void R65816::op_rts() { +auto R65816::op_rts() { op_io(); op_io(); rd.l = op_readstack(); @@ -155,7 +154,7 @@ L op_io(); regs.pc.w = ++rd.w; } -void R65816::op_rtl_e() { +auto R65816::op_rtl_e() { op_io(); op_io(); rd.l = op_readstackn(); @@ -166,7 +165,7 @@ L rd.b = op_readstackn(); regs.s.h = 0x01; } -void R65816::op_rtl_n() { +auto R65816::op_rtl_n() { op_io(); op_io(); rd.l = op_readstackn(); diff --git a/processor/r65816/opcode_read.cpp b/processor/r65816/opcode_read.cpp index 63832c6a..94072ad7 100644 --- a/processor/r65816/opcode_read.cpp +++ b/processor/r65816/opcode_read.cpp @@ -1,33 +1,33 @@ -template void R65816::op_read_const_b() { +auto R65816::op_read_const_b(fp op) { L rd.l = op_readpc(); call(op); } -template void R65816::op_read_const_w() { +auto R65816::op_read_const_w(fp op) { rd.l = op_readpc(); L rd.h = op_readpc(); call(op); } -void R65816::op_read_bit_const_b() { +auto R65816::op_read_bit_const_b() { L rd.l = op_readpc(); regs.p.z = ((rd.l & regs.a.l) == 0); } -void R65816::op_read_bit_const_w() { +auto R65816::op_read_bit_const_w() { rd.l = op_readpc(); L rd.h = op_readpc(); regs.p.z = ((rd.w & regs.a.w) == 0); } -template void R65816::op_read_addr_b() { +auto R65816::op_read_addr_b(fp op) { aa.l = op_readpc(); aa.h = op_readpc(); L rd.l = op_readdbr(aa.w); call(op); } -template void R65816::op_read_addr_w() { +auto R65816::op_read_addr_w(fp op) { aa.l = op_readpc(); aa.h = op_readpc(); rd.l = op_readdbr(aa.w + 0); @@ -35,7 +35,7 @@ L rd.h = op_readdbr(aa.w + 1); call(op); } -template void R65816::op_read_addrx_b() { +auto R65816::op_read_addrx_b(fp op) { aa.l = op_readpc(); aa.h = op_readpc(); op_io_cond4(aa.w, aa.w + regs.x.w); @@ -43,7 +43,7 @@ L rd.l = op_readdbr(aa.w + regs.x.w); call(op); } -template void R65816::op_read_addrx_w() { +auto R65816::op_read_addrx_w(fp op) { aa.l = op_readpc(); aa.h = op_readpc(); op_io_cond4(aa.w, aa.w + regs.x.w); @@ -52,7 +52,7 @@ L rd.h = op_readdbr(aa.w + regs.x.w + 1); call(op); } -template void R65816::op_read_addry_b() { +auto R65816::op_read_addry_b(fp op) { aa.l = op_readpc(); aa.h = op_readpc(); op_io_cond4(aa.w, aa.w + regs.y.w); @@ -60,7 +60,7 @@ L rd.l = op_readdbr(aa.w + regs.y.w); call(op); } -template void R65816::op_read_addry_w() { +auto R65816::op_read_addry_w(fp op) { aa.l = op_readpc(); aa.h = op_readpc(); op_io_cond4(aa.w, aa.w + regs.y.w); @@ -69,7 +69,7 @@ L rd.h = op_readdbr(aa.w + regs.y.w + 1); call(op); } -template void R65816::op_read_long_b() { +auto R65816::op_read_long_b(fp op) { aa.l = op_readpc(); aa.h = op_readpc(); aa.b = op_readpc(); @@ -77,7 +77,7 @@ L rd.l = op_readlong(aa.d); call(op); } -template void R65816::op_read_long_w() { +auto R65816::op_read_long_w(fp op) { aa.l = op_readpc(); aa.h = op_readpc(); aa.b = op_readpc(); @@ -86,7 +86,7 @@ L rd.h = op_readlong(aa.d + 1); call(op); } -template void R65816::op_read_longx_b() { +auto R65816::op_read_longx_b(fp op) { aa.l = op_readpc(); aa.h = op_readpc(); aa.b = op_readpc(); @@ -94,7 +94,7 @@ L rd.l = op_readlong(aa.d + regs.x.w); call(op); } -template void R65816::op_read_longx_w() { +auto R65816::op_read_longx_w(fp op) { aa.l = op_readpc(); aa.h = op_readpc(); aa.b = op_readpc(); @@ -103,14 +103,14 @@ L rd.h = op_readlong(aa.d + regs.x.w + 1); call(op); } -template void R65816::op_read_dp_b() { +auto R65816::op_read_dp_b(fp op) { dp = op_readpc(); op_io_cond2(); L rd.l = op_readdp(dp); call(op); } -template void R65816::op_read_dp_w() { +auto R65816::op_read_dp_w(fp op) { dp = op_readpc(); op_io_cond2(); rd.l = op_readdp(dp + 0); @@ -118,24 +118,24 @@ L rd.h = op_readdp(dp + 1); call(op); } -template void R65816::op_read_dpr_b() { +auto R65816::op_read_dpr_b(fp op, reg16_t& reg) { dp = op_readpc(); op_io_cond2(); op_io(); -L rd.l = op_readdp(dp + regs.r[n].w); +L rd.l = op_readdp(dp + reg.w); call(op); } -template void R65816::op_read_dpr_w() { +auto R65816::op_read_dpr_w(fp op, reg16_t& reg) { dp = op_readpc(); op_io_cond2(); op_io(); - rd.l = op_readdp(dp + regs.r[n].w + 0); -L rd.h = op_readdp(dp + regs.r[n].w + 1); + rd.l = op_readdp(dp + reg.w + 0); +L rd.h = op_readdp(dp + reg.w + 1); call(op); } -template void R65816::op_read_idp_b() { +auto R65816::op_read_idp_b(fp op) { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -144,7 +144,7 @@ L rd.l = op_readdbr(aa.w); call(op); } -template void R65816::op_read_idp_w() { +auto R65816::op_read_idp_w(fp op) { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -154,7 +154,7 @@ L rd.h = op_readdbr(aa.w + 1); call(op); } -template void R65816::op_read_idpx_b() { +auto R65816::op_read_idpx_b(fp op) { dp = op_readpc(); op_io_cond2(); op_io(); @@ -164,7 +164,7 @@ L rd.l = op_readdbr(aa.w); call(op); } -template void R65816::op_read_idpx_w() { +auto R65816::op_read_idpx_w(fp op) { dp = op_readpc(); op_io_cond2(); op_io(); @@ -175,7 +175,7 @@ L rd.h = op_readdbr(aa.w + 1); call(op); } -template void R65816::op_read_idpy_b() { +auto R65816::op_read_idpy_b(fp op) { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -185,7 +185,7 @@ L rd.l = op_readdbr(aa.w + regs.y.w); call(op); } -template void R65816::op_read_idpy_w() { +auto R65816::op_read_idpy_w(fp op) { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -196,7 +196,7 @@ L rd.h = op_readdbr(aa.w + regs.y.w + 1); call(op); } -template void R65816::op_read_ildp_b() { +auto R65816::op_read_ildp_b(fp op) { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -206,7 +206,7 @@ L rd.l = op_readlong(aa.d); call(op); } -template void R65816::op_read_ildp_w() { +auto R65816::op_read_ildp_w(fp op) { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -217,7 +217,7 @@ L rd.h = op_readlong(aa.d + 1); call(op); } -template void R65816::op_read_ildpy_b() { +auto R65816::op_read_ildpy_b(fp op) { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -227,7 +227,7 @@ L rd.l = op_readlong(aa.d + regs.y.w); call(op); } -template void R65816::op_read_ildpy_w() { +auto R65816::op_read_ildpy_w(fp op) { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -238,14 +238,14 @@ L rd.h = op_readlong(aa.d + regs.y.w + 1); call(op); } -template void R65816::op_read_sr_b() { +auto R65816::op_read_sr_b(fp op) { sp = op_readpc(); op_io(); L rd.l = op_readsp(sp); call(op); } -template void R65816::op_read_sr_w() { +auto R65816::op_read_sr_w(fp op) { sp = op_readpc(); op_io(); rd.l = op_readsp(sp + 0); @@ -253,7 +253,7 @@ L rd.h = op_readsp(sp + 1); call(op); } -template void R65816::op_read_isry_b() { +auto R65816::op_read_isry_b(fp op) { sp = op_readpc(); op_io(); aa.l = op_readsp(sp + 0); @@ -263,7 +263,7 @@ L rd.l = op_readdbr(aa.w + regs.y.w); call(op); } -template void R65816::op_read_isry_w() { +auto R65816::op_read_isry_w(fp op) { sp = op_readpc(); op_io(); aa.l = op_readsp(sp + 0); diff --git a/processor/r65816/opcode_rmw.cpp b/processor/r65816/opcode_rmw.cpp index 3aa4f9af..857e7407 100644 --- a/processor/r65816/opcode_rmw.cpp +++ b/processor/r65816/opcode_rmw.cpp @@ -1,18 +1,18 @@ -template void R65816::op_adjust_imm_b() { +auto R65816::op_adjust_imm_b(reg16_t& reg, signed adjust) { L op_io_irq(); - regs.r[n].l += adjust; - regs.p.n = (regs.r[n].l & 0x80); - regs.p.z = (regs.r[n].l == 0); + reg.l += adjust; + regs.p.n = (reg.l & 0x80); + regs.p.z = (reg.l == 0); } -template void R65816::op_adjust_imm_w() { +auto R65816::op_adjust_imm_w(reg16_t& reg, signed adjust) { L op_io_irq(); - regs.r[n].w += adjust; - regs.p.n = (regs.r[n].w & 0x8000); - regs.p.z = (regs.r[n].w == 0); + reg.w += adjust; + regs.p.n = (reg.w & 0x8000); + regs.p.z = (reg.w == 0); } -void R65816::op_asl_imm_b() { +auto R65816::op_asl_imm_b() { L op_io_irq(); regs.p.c = (regs.a.l & 0x80); regs.a.l <<= 1; @@ -20,7 +20,7 @@ L op_io_irq(); regs.p.z = (regs.a.l == 0); } -void R65816::op_asl_imm_w() { +auto R65816::op_asl_imm_w() { L op_io_irq(); regs.p.c = (regs.a.w & 0x8000); regs.a.w <<= 1; @@ -28,7 +28,7 @@ L op_io_irq(); regs.p.z = (regs.a.w == 0); } -void R65816::op_lsr_imm_b() { +auto R65816::op_lsr_imm_b() { L op_io_irq(); regs.p.c = (regs.a.l & 0x01); regs.a.l >>= 1; @@ -36,7 +36,7 @@ L op_io_irq(); regs.p.z = (regs.a.l == 0); } -void R65816::op_lsr_imm_w() { +auto R65816::op_lsr_imm_w() { L op_io_irq(); regs.p.c = (regs.a.w & 0x0001); regs.a.w >>= 1; @@ -44,7 +44,7 @@ L op_io_irq(); regs.p.z = (regs.a.w == 0); } -void R65816::op_rol_imm_b() { +auto R65816::op_rol_imm_b() { L op_io_irq(); bool carry = regs.p.c; regs.p.c = (regs.a.l & 0x80); @@ -53,7 +53,7 @@ L op_io_irq(); regs.p.z = (regs.a.l == 0); } -void R65816::op_rol_imm_w() { +auto R65816::op_rol_imm_w() { L op_io_irq(); bool carry = regs.p.c; regs.p.c = (regs.a.w & 0x8000); @@ -62,7 +62,7 @@ L op_io_irq(); regs.p.z = (regs.a.w == 0); } -void R65816::op_ror_imm_b() { +auto R65816::op_ror_imm_b() { L op_io_irq(); bool carry = regs.p.c; regs.p.c = (regs.a.l & 0x01); @@ -71,7 +71,7 @@ L op_io_irq(); regs.p.z = (regs.a.l == 0); } -void R65816::op_ror_imm_w() { +auto R65816::op_ror_imm_w() { L op_io_irq(); bool carry = regs.p.c; regs.p.c = (regs.a.w & 0x0001); @@ -80,7 +80,7 @@ L op_io_irq(); regs.p.z = (regs.a.w == 0); } -template void R65816::op_adjust_addr_b() { +auto R65816::op_adjust_addr_b(fp op) { aa.l = op_readpc(); aa.h = op_readpc(); rd.l = op_readdbr(aa.w); @@ -89,7 +89,7 @@ template void R65816::op_adjust_addr_b() { L op_writedbr(aa.w, rd.l); } -template void R65816::op_adjust_addr_w() { +auto R65816::op_adjust_addr_w(fp op) { aa.l = op_readpc(); aa.h = op_readpc(); rd.l = op_readdbr(aa.w + 0); @@ -100,7 +100,7 @@ template void R65816::op_adjust_addr_w() { L op_writedbr(aa.w + 0, rd.l); } -template void R65816::op_adjust_addrx_b() { +auto R65816::op_adjust_addrx_b(fp op) { aa.l = op_readpc(); aa.h = op_readpc(); op_io(); @@ -110,7 +110,7 @@ template void R65816::op_adjust_addrx_b() { L op_writedbr(aa.w + regs.x.w, rd.l); } -template void R65816::op_adjust_addrx_w() { +auto R65816::op_adjust_addrx_w(fp op) { aa.l = op_readpc(); aa.h = op_readpc(); op_io(); @@ -122,7 +122,7 @@ template void R65816::op_adjust_addrx_w() { L op_writedbr(aa.w + regs.x.w + 0, rd.l); } -template void R65816::op_adjust_dp_b() { +auto R65816::op_adjust_dp_b(fp op) { dp = op_readpc(); op_io_cond2(); rd.l = op_readdp(dp); @@ -131,7 +131,7 @@ template void R65816::op_adjust_dp_b() { L op_writedp(dp, rd.l); } -template void R65816::op_adjust_dp_w() { +auto R65816::op_adjust_dp_w(fp op) { dp = op_readpc(); op_io_cond2(); rd.l = op_readdp(dp + 0); @@ -142,7 +142,7 @@ template void R65816::op_adjust_dp_w() { L op_writedp(dp + 0, rd.l); } -template void R65816::op_adjust_dpx_b() { +auto R65816::op_adjust_dpx_b(fp op) { dp = op_readpc(); op_io_cond2(); op_io(); @@ -152,7 +152,7 @@ template void R65816::op_adjust_dpx_b() { L op_writedp(dp + regs.x.w, rd.l); } -template void R65816::op_adjust_dpx_w() { +auto R65816::op_adjust_dpx_w(fp op) { dp = op_readpc(); op_io_cond2(); op_io(); diff --git a/processor/r65816/opcode_write.cpp b/processor/r65816/opcode_write.cpp index c23208ef..69efe11e 100644 --- a/processor/r65816/opcode_write.cpp +++ b/processor/r65816/opcode_write.cpp @@ -1,75 +1,75 @@ -template void R65816::op_write_addr_b() { +auto R65816::op_write_addr_b(reg16_t& reg) { aa.l = op_readpc(); aa.h = op_readpc(); -L op_writedbr(aa.w, regs.r[n]); +L op_writedbr(aa.w, reg); } -template void R65816::op_write_addr_w() { +auto R65816::op_write_addr_w(reg16_t& reg) { aa.l = op_readpc(); aa.h = op_readpc(); - op_writedbr(aa.w + 0, regs.r[n] >> 0); -L op_writedbr(aa.w + 1, regs.r[n] >> 8); + op_writedbr(aa.w + 0, reg >> 0); +L op_writedbr(aa.w + 1, reg >> 8); } -template void R65816::op_write_addrr_b() { +auto R65816::op_write_addrr_b(reg16_t& reg, reg16_t& idx) { aa.l = op_readpc(); aa.h = op_readpc(); op_io(); -L op_writedbr(aa.w + regs.r[i], regs.r[n]); +L op_writedbr(aa.w + idx, reg); } -template void R65816::op_write_addrr_w() { +auto R65816::op_write_addrr_w(reg16_t& reg, reg16_t& idx) { aa.l = op_readpc(); aa.h = op_readpc(); op_io(); - op_writedbr(aa.w + regs.r[i] + 0, regs.r[n] >> 0); -L op_writedbr(aa.w + regs.r[i] + 1, regs.r[n] >> 8); + op_writedbr(aa.w + idx + 0, reg >> 0); +L op_writedbr(aa.w + idx + 1, reg >> 8); } -template void R65816::op_write_longr_b() { +auto R65816::op_write_longr_b(reg16_t& idx) { aa.l = op_readpc(); aa.h = op_readpc(); aa.b = op_readpc(); -L op_writelong(aa.d + regs.r[i], regs.a.l); +L op_writelong(aa.d + idx, regs.a.l); } -template void R65816::op_write_longr_w() { +auto R65816::op_write_longr_w(reg16_t& idx) { aa.l = op_readpc(); aa.h = op_readpc(); aa.b = op_readpc(); - op_writelong(aa.d + regs.r[i] + 0, regs.a.l); -L op_writelong(aa.d + regs.r[i] + 1, regs.a.h); + op_writelong(aa.d + idx + 0, regs.a.l); +L op_writelong(aa.d + idx + 1, regs.a.h); } -template void R65816::op_write_dp_b() { +auto R65816::op_write_dp_b(reg16_t& reg) { dp = op_readpc(); op_io_cond2(); -L op_writedp(dp, regs.r[n]); +L op_writedp(dp, reg); } -template void R65816::op_write_dp_w() { +auto R65816::op_write_dp_w(reg16_t& reg) { dp = op_readpc(); op_io_cond2(); - op_writedp(dp + 0, regs.r[n] >> 0); -L op_writedp(dp + 1, regs.r[n] >> 8); + op_writedp(dp + 0, reg >> 0); +L op_writedp(dp + 1, reg >> 8); } -template void R65816::op_write_dpr_b() { +auto R65816::op_write_dpr_b(reg16_t& reg, reg16_t& idx) { dp = op_readpc(); op_io_cond2(); op_io(); -L op_writedp(dp + regs.r[i], regs.r[n]); +L op_writedp(dp + idx, reg); } -template void R65816::op_write_dpr_w() { +auto R65816::op_write_dpr_w(reg16_t& reg, reg16_t& idx) { dp = op_readpc(); op_io_cond2(); op_io(); - op_writedp(dp + regs.r[i] + 0, regs.r[n] >> 0); -L op_writedp(dp + regs.r[i] + 1, regs.r[n] >> 8); + op_writedp(dp + idx + 0, reg >> 0); +L op_writedp(dp + idx + 1, reg >> 8); } -void R65816::op_sta_idp_b() { +auto R65816::op_sta_idp_b() { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -77,7 +77,7 @@ void R65816::op_sta_idp_b() { L op_writedbr(aa.w, regs.a.l); } -void R65816::op_sta_idp_w() { +auto R65816::op_sta_idp_w() { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -86,7 +86,7 @@ void R65816::op_sta_idp_w() { L op_writedbr(aa.w + 1, regs.a.h); } -void R65816::op_sta_ildp_b() { +auto R65816::op_sta_ildp_b() { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -95,7 +95,7 @@ void R65816::op_sta_ildp_b() { L op_writelong(aa.d, regs.a.l); } -void R65816::op_sta_ildp_w() { +auto R65816::op_sta_ildp_w() { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -105,7 +105,7 @@ void R65816::op_sta_ildp_w() { L op_writelong(aa.d + 1, regs.a.h); } -void R65816::op_sta_idpx_b() { +auto R65816::op_sta_idpx_b() { dp = op_readpc(); op_io_cond2(); op_io(); @@ -114,7 +114,7 @@ void R65816::op_sta_idpx_b() { L op_writedbr(aa.w, regs.a.l); } -void R65816::op_sta_idpx_w() { +auto R65816::op_sta_idpx_w() { dp = op_readpc(); op_io_cond2(); op_io(); @@ -124,7 +124,7 @@ void R65816::op_sta_idpx_w() { L op_writedbr(aa.w + 1, regs.a.h); } -void R65816::op_sta_idpy_b() { +auto R65816::op_sta_idpy_b() { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -133,7 +133,7 @@ void R65816::op_sta_idpy_b() { L op_writedbr(aa.w + regs.y.w, regs.a.l); } -void R65816::op_sta_idpy_w() { +auto R65816::op_sta_idpy_w() { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -143,7 +143,7 @@ void R65816::op_sta_idpy_w() { L op_writedbr(aa.w + regs.y.w + 1, regs.a.h); } -void R65816::op_sta_ildpy_b() { +auto R65816::op_sta_ildpy_b() { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -152,7 +152,7 @@ void R65816::op_sta_ildpy_b() { L op_writelong(aa.d + regs.y.w, regs.a.l); } -void R65816::op_sta_ildpy_w() { +auto R65816::op_sta_ildpy_w() { dp = op_readpc(); op_io_cond2(); aa.l = op_readdp(dp + 0); @@ -162,20 +162,20 @@ void R65816::op_sta_ildpy_w() { L op_writelong(aa.d + regs.y.w + 1, regs.a.h); } -void R65816::op_sta_sr_b() { +auto R65816::op_sta_sr_b() { sp = op_readpc(); op_io(); L op_writesp(sp, regs.a.l); } -void R65816::op_sta_sr_w() { +auto R65816::op_sta_sr_w() { sp = op_readpc(); op_io(); op_writesp(sp + 0, regs.a.l); L op_writesp(sp + 1, regs.a.h); } -void R65816::op_sta_isry_b() { +auto R65816::op_sta_isry_b() { sp = op_readpc(); op_io(); aa.l = op_readsp(sp + 0); @@ -184,7 +184,7 @@ void R65816::op_sta_isry_b() { L op_writedbr(aa.w + regs.y.w, regs.a.l); } -void R65816::op_sta_isry_w() { +auto R65816::op_sta_isry_w() { sp = op_readpc(); op_io(); aa.l = op_readsp(sp + 0); diff --git a/processor/r65816/r65816.cpp b/processor/r65816/r65816.cpp index eb05aeca..3e76c828 100644 --- a/processor/r65816/r65816.cpp +++ b/processor/r65816/r65816.cpp @@ -8,12 +8,6 @@ namespace Processor { #include "serialization.cpp" #define L last_cycle(); -#define A 0 -#define X 1 -#define Y 2 -#define Z 3 -#define S 4 -#define D 5 #define call(op) (this->*op)() #include "opcode_read.cpp" @@ -21,15 +15,9 @@ namespace Processor { #include "opcode_rmw.cpp" #include "opcode_pc.cpp" #include "opcode_misc.cpp" -#include "table.cpp" +#include "switch.cpp" #undef L -#undef A -#undef X -#undef Y -#undef Z -#undef S -#undef D #undef call //immediate, 2-cycle opcodes with I/O cycle will become bus read @@ -40,7 +28,7 @@ namespace Processor { // tcd, tcs, tdc, tsc, tsx, txs, // inc, inx, iny, dec, dex, dey, // asl, lsr, rol, ror, nop, xce. -alwaysinline void R65816::op_io_irq() { +auto R65816::op_io_irq() -> void { if(interrupt_pending()) { //modify I/O cycle to bus read cycle, do not increment PC op_read(regs.pc.d); @@ -49,25 +37,25 @@ alwaysinline void R65816::op_io_irq() { } } -alwaysinline void R65816::op_io_cond2() { +auto R65816::op_io_cond2() -> void { if(regs.d.l != 0x00) { op_io(); } } -alwaysinline void R65816::op_io_cond4(uint16 x, uint16 y) { +auto R65816::op_io_cond4(uint16 x, uint16 y) -> void { if(!regs.p.x || (x & 0xff00) != (y & 0xff00)) { op_io(); } } -alwaysinline void R65816::op_io_cond6(uint16 addr) { +auto R65816::op_io_cond6(uint16 addr) -> void { if(regs.e && (regs.pc.w & 0xff00) != (addr & 0xff00)) { op_io(); } } -void R65816::op_irq() { +auto R65816::op_irq() -> void { op_read(regs.pc.d); op_io(); if(!regs.e) op_writestack(regs.pc.b); @@ -82,8 +70,4 @@ void R65816::op_irq() { regs.pc.w = rd.w; } -R65816::R65816() { - initialize_opcode_table(); -} - } diff --git a/processor/r65816/r65816.hpp b/processor/r65816/r65816.hpp index 29a77b24..88ac1c33 100644 --- a/processor/r65816/r65816.hpp +++ b/processor/r65816/r65816.hpp @@ -12,219 +12,218 @@ struct R65816 { #include "memory.hpp" #include "disassembler.hpp" + using fp = auto (R65816::*)() -> void; + + virtual auto op_io() -> void = 0; + virtual auto op_read(uint32_t addr) -> uint8_t = 0; + virtual auto op_write(uint32_t addr, uint8_t data) -> void = 0; + virtual auto last_cycle() -> void = 0; + virtual auto interrupt_pending() -> bool = 0; + virtual auto op_irq() -> void; + + virtual auto disassembler_read(uint32 addr) -> uint8 { return 0u; } + + //r65816.cpp + alwaysinline auto op_io_irq() -> void; + alwaysinline auto op_io_cond2() -> void; + alwaysinline auto op_io_cond4(uint16 x, uint16 y) -> void; + alwaysinline auto op_io_cond6(uint16 addr) -> void; + + //algorithms.cpp + auto op_adc_b(); + auto op_adc_w(); + auto op_and_b(); + auto op_and_w(); + auto op_bit_b(); + auto op_bit_w(); + auto op_cmp_b(); + auto op_cmp_w(); + auto op_cpx_b(); + auto op_cpx_w(); + auto op_cpy_b(); + auto op_cpy_w(); + auto op_eor_b(); + auto op_eor_w(); + auto op_lda_b(); + auto op_lda_w(); + auto op_ldx_b(); + auto op_ldx_w(); + auto op_ldy_b(); + auto op_ldy_w(); + auto op_ora_b(); + auto op_ora_w(); + auto op_sbc_b(); + auto op_sbc_w(); + + auto op_inc_b(); + auto op_inc_w(); + auto op_dec_b(); + auto op_dec_w(); + auto op_asl_b(); + auto op_asl_w(); + auto op_lsr_b(); + auto op_lsr_w(); + auto op_rol_b(); + auto op_rol_w(); + auto op_ror_b(); + auto op_ror_w(); + auto op_trb_b(); + auto op_trb_w(); + auto op_tsb_b(); + auto op_tsb_w(); + + //opcode_read.cpp + auto op_read_const_b(fp); + auto op_read_const_w(fp); + auto op_read_bit_const_b(); + auto op_read_bit_const_w(); + auto op_read_addr_b(fp); + auto op_read_addr_w(fp); + auto op_read_addrx_b(fp); + auto op_read_addrx_w(fp); + auto op_read_addry_b(fp); + auto op_read_addry_w(fp); + auto op_read_long_b(fp); + auto op_read_long_w(fp); + auto op_read_longx_b(fp); + auto op_read_longx_w(fp); + auto op_read_dp_b(fp); + auto op_read_dp_w(fp); + auto op_read_dpr_b(fp, reg16_t&); + auto op_read_dpr_w(fp, reg16_t&); + auto op_read_idp_b(fp); + auto op_read_idp_w(fp); + auto op_read_idpx_b(fp); + auto op_read_idpx_w(fp); + auto op_read_idpy_b(fp); + auto op_read_idpy_w(fp); + auto op_read_ildp_b(fp); + auto op_read_ildp_w(fp); + auto op_read_ildpy_b(fp); + auto op_read_ildpy_w(fp); + auto op_read_sr_b(fp); + auto op_read_sr_w(fp); + auto op_read_isry_b(fp); + auto op_read_isry_w(fp); + + //opcode_write.cpp + auto op_write_addr_b(reg16_t&); + auto op_write_addr_w(reg16_t&); + auto op_write_addrr_b(reg16_t&, reg16_t&); + auto op_write_addrr_w(reg16_t&, reg16_t&); + auto op_write_longr_b(reg16_t&); + auto op_write_longr_w(reg16_t&); + auto op_write_dp_b(reg16_t&); + auto op_write_dp_w(reg16_t&); + auto op_write_dpr_b(reg16_t&, reg16_t&); + auto op_write_dpr_w(reg16_t&, reg16_t&); + auto op_sta_idp_b(); + auto op_sta_idp_w(); + auto op_sta_ildp_b(); + auto op_sta_ildp_w(); + auto op_sta_idpx_b(); + auto op_sta_idpx_w(); + auto op_sta_idpy_b(); + auto op_sta_idpy_w(); + auto op_sta_ildpy_b(); + auto op_sta_ildpy_w(); + auto op_sta_sr_b(); + auto op_sta_sr_w(); + auto op_sta_isry_b(); + auto op_sta_isry_w(); + + //opcode_rmw.cpp + auto op_adjust_imm_b(reg16_t&, signed); + auto op_adjust_imm_w(reg16_t&, signed); + auto op_asl_imm_b(); + auto op_asl_imm_w(); + auto op_lsr_imm_b(); + auto op_lsr_imm_w(); + auto op_rol_imm_b(); + auto op_rol_imm_w(); + auto op_ror_imm_b(); + auto op_ror_imm_w(); + auto op_adjust_addr_b(fp op); + auto op_adjust_addr_w(fp op); + auto op_adjust_addrx_b(fp op); + auto op_adjust_addrx_w(fp op); + auto op_adjust_dp_b(fp op); + auto op_adjust_dp_w(fp op); + auto op_adjust_dpx_b(fp op); + auto op_adjust_dpx_w(fp op); + + //opcode_pc.cpp + auto op_branch(bool flag, bool value); + auto op_bra(); + auto op_brl(); + auto op_jmp_addr(); + auto op_jmp_long(); + auto op_jmp_iaddr(); + auto op_jmp_iaddrx(); + auto op_jmp_iladdr(); + auto op_jsr_addr(); + auto op_jsr_long_e(); + auto op_jsr_long_n(); + auto op_jsr_iaddrx_e(); + auto op_jsr_iaddrx_n(); + auto op_rti_e(); + auto op_rti_n(); + auto op_rts(); + auto op_rtl_e(); + auto op_rtl_n(); + + //opcode_misc.cpp + auto op_nop(); + auto op_wdm(); + auto op_xba(); + auto op_move_b(signed adjust); + auto op_move_w(signed adjust); + auto op_interrupt_e(uint16); + auto op_interrupt_n(uint16); + auto op_stp(); + auto op_wai(); + auto op_xce(); + auto op_flag(bool& flag, bool value); + auto op_pflag_e(bool); + auto op_pflag_n(bool); + auto op_transfer_b(reg16_t&, reg16_t&); + auto op_transfer_w(reg16_t&, reg16_t&); + auto op_tcs_e(); + auto op_tcs_n(); + auto op_tsx_b(); + auto op_tsx_w(); + auto op_txs_e(); + auto op_txs_n(); + auto op_push_b(reg16_t&); + auto op_push_w(reg16_t&); + auto op_phd_e(); + auto op_phd_n(); + auto op_phb(); + auto op_phk(); + auto op_php(); + auto op_pull_b(reg16_t&); + auto op_pull_w(reg16_t&); + auto op_pld_e(); + auto op_pld_n(); + auto op_plb(); + auto op_plp_e(); + auto op_plp_n(); + auto op_pea_e(); + auto op_pea_n(); + auto op_pei_e(); + auto op_pei_n(); + auto op_per_e(); + auto op_per_n(); + + //switch.cpp + auto op_exec() -> void; + + //serialization.cpp + auto serialize(serializer&) -> void; + regs_t regs; reg24_t aa, rd; - uint8_t sp, dp; - - virtual void op_io() = 0; - virtual uint8_t op_read(uint32_t addr) = 0; - virtual void op_write(uint32_t addr, uint8_t data) = 0; - virtual void last_cycle() = 0; - virtual bool interrupt_pending() = 0; - virtual void op_irq(); - - virtual uint8 disassembler_read(uint32 addr) { return 0u; } - - void op_io_irq(); - void op_io_cond2(); - void op_io_cond4(uint16 x, uint16 y); - void op_io_cond6(uint16 addr); - - void op_adc_b(); - void op_adc_w(); - void op_and_b(); - void op_and_w(); - void op_bit_b(); - void op_bit_w(); - void op_cmp_b(); - void op_cmp_w(); - void op_cpx_b(); - void op_cpx_w(); - void op_cpy_b(); - void op_cpy_w(); - void op_eor_b(); - void op_eor_w(); - void op_lda_b(); - void op_lda_w(); - void op_ldx_b(); - void op_ldx_w(); - void op_ldy_b(); - void op_ldy_w(); - void op_ora_b(); - void op_ora_w(); - void op_sbc_b(); - void op_sbc_w(); - - void op_inc_b(); - void op_inc_w(); - void op_dec_b(); - void op_dec_w(); - void op_asl_b(); - void op_asl_w(); - void op_lsr_b(); - void op_lsr_w(); - void op_rol_b(); - void op_rol_w(); - void op_ror_b(); - void op_ror_w(); - void op_trb_b(); - void op_trb_w(); - void op_tsb_b(); - void op_tsb_w(); - - template void op_read_const_b(); - template void op_read_const_w(); - void op_read_bit_const_b(); - void op_read_bit_const_w(); - template void op_read_addr_b(); - template void op_read_addr_w(); - template void op_read_addrx_b(); - template void op_read_addrx_w(); - template void op_read_addry_b(); - template void op_read_addry_w(); - template void op_read_long_b(); - template void op_read_long_w(); - template void op_read_longx_b(); - template void op_read_longx_w(); - template void op_read_dp_b(); - template void op_read_dp_w(); - template void op_read_dpr_b(); - template void op_read_dpr_w(); - template void op_read_idp_b(); - template void op_read_idp_w(); - template void op_read_idpx_b(); - template void op_read_idpx_w(); - template void op_read_idpy_b(); - template void op_read_idpy_w(); - template void op_read_ildp_b(); - template void op_read_ildp_w(); - template void op_read_ildpy_b(); - template void op_read_ildpy_w(); - template void op_read_sr_b(); - template void op_read_sr_w(); - template void op_read_isry_b(); - template void op_read_isry_w(); - - template void op_write_addr_b(); - template void op_write_addr_w(); - template void op_write_addrr_b(); - template void op_write_addrr_w(); - template void op_write_longr_b(); - template void op_write_longr_w(); - template void op_write_dp_b(); - template void op_write_dp_w(); - template void op_write_dpr_b(); - template void op_write_dpr_w(); - void op_sta_idp_b(); - void op_sta_idp_w(); - void op_sta_ildp_b(); - void op_sta_ildp_w(); - void op_sta_idpx_b(); - void op_sta_idpx_w(); - void op_sta_idpy_b(); - void op_sta_idpy_w(); - void op_sta_ildpy_b(); - void op_sta_ildpy_w(); - void op_sta_sr_b(); - void op_sta_sr_w(); - void op_sta_isry_b(); - void op_sta_isry_w(); - - template void op_adjust_imm_b(); - template void op_adjust_imm_w(); - void op_asl_imm_b(); - void op_asl_imm_w(); - void op_lsr_imm_b(); - void op_lsr_imm_w(); - void op_rol_imm_b(); - void op_rol_imm_w(); - void op_ror_imm_b(); - void op_ror_imm_w(); - template void op_adjust_addr_b(); - template void op_adjust_addr_w(); - template void op_adjust_addrx_b(); - template void op_adjust_addrx_w(); - template void op_adjust_dp_b(); - template void op_adjust_dp_w(); - template void op_adjust_dpx_b(); - template void op_adjust_dpx_w(); - - template void op_branch(); - void op_bra(); - void op_brl(); - void op_jmp_addr(); - void op_jmp_long(); - void op_jmp_iaddr(); - void op_jmp_iaddrx(); - void op_jmp_iladdr(); - void op_jsr_addr(); - void op_jsr_long_e(); - void op_jsr_long_n(); - void op_jsr_iaddrx_e(); - void op_jsr_iaddrx_n(); - void op_rti_e(); - void op_rti_n(); - void op_rts(); - void op_rtl_e(); - void op_rtl_n(); - - void op_nop(); - void op_wdm(); - void op_xba(); - template void op_move_b(); - template void op_move_w(); - template void op_interrupt_e(); - template void op_interrupt_n(); - void op_stp(); - void op_wai(); - void op_xce(); - template void op_flag(); - template void op_pflag_e(); - template void op_pflag_n(); - template void op_transfer_b(); - template void op_transfer_w(); - void op_tcs_e(); - void op_tcs_n(); - void op_tsx_b(); - void op_tsx_w(); - void op_txs_e(); - void op_txs_n(); - template void op_push_b(); - template void op_push_w(); - void op_phd_e(); - void op_phd_n(); - void op_phb(); - void op_phk(); - void op_php(); - template void op_pull_b(); - template void op_pull_w(); - void op_pld_e(); - void op_pld_n(); - void op_plb(); - void op_plp_e(); - void op_plp_n(); - void op_pea_e(); - void op_pea_n(); - void op_pei_e(); - void op_pei_n(); - void op_per_e(); - void op_per_n(); - - void (R65816::**opcode_table)(); - void (R65816::*op_table[5 * 256])(); - void initialize_opcode_table(); - void update_table(); - - enum { - table_EM = 0, // 8-bit accumulator, 8-bit index (emulation mode) - table_MX = 256, // 8-bit accumulator, 8-bit index - table_Mx = 512, // 8-bit accumulator, 16-bit index - table_mX = 768, //16-bit accumulator, 8-bit index - table_mx = 1024, //16-bit accumulator, 16-bit index - }; - - void serialize(serializer&); - R65816(); + uint8 sp, dp; }; } diff --git a/processor/r65816/registers.hpp b/processor/r65816/registers.hpp index adcf797f..e929255a 100644 --- a/processor/r65816/registers.hpp +++ b/processor/r65816/registers.hpp @@ -1,83 +1,80 @@ struct flag_t { - bool n, v, m, x, d, i, z, c; + bool n{0}; + bool v{0}; + bool m{0}; + bool x{0}; + bool d{0}; + bool i{0}; + bool z{0}; + bool c{0}; inline operator unsigned() const { return (n << 7) + (v << 6) + (m << 5) + (x << 4) + (d << 3) + (i << 2) + (z << 1) + (c << 0); } - inline unsigned operator=(uint8 data) { + inline auto operator=(uint8 data) -> unsigned { n = data & 0x80; v = data & 0x40; m = data & 0x20; x = data & 0x10; d = data & 0x08; i = data & 0x04; z = data & 0x02; c = data & 0x01; return data; } - - inline unsigned operator|=(unsigned data) { return operator=(operator unsigned() | data); } - inline unsigned operator^=(unsigned data) { return operator=(operator unsigned() ^ data); } - inline unsigned operator&=(unsigned data) { return operator=(operator unsigned() & data); } - - flag_t() : n(0), v(0), m(0), x(0), d(0), i(0), z(0), c(0) {} }; struct reg16_t { union { - uint16 w; + uint16 w = 0; struct { uint8 order_lsb2(l, h); }; }; inline operator unsigned() const { return w; } - inline unsigned operator = (unsigned i) { return w = i; } - inline unsigned operator |= (unsigned i) { return w |= i; } - inline unsigned operator ^= (unsigned i) { return w ^= i; } - inline unsigned operator &= (unsigned i) { return w &= i; } - inline unsigned operator <<= (unsigned i) { return w <<= i; } - inline unsigned operator >>= (unsigned i) { return w >>= i; } - inline unsigned operator += (unsigned i) { return w += i; } - inline unsigned operator -= (unsigned i) { return w -= i; } - inline unsigned operator *= (unsigned i) { return w *= i; } - inline unsigned operator /= (unsigned i) { return w /= i; } - inline unsigned operator %= (unsigned i) { return w %= i; } - - reg16_t() : w(0) {} + inline auto operator = (unsigned i) -> unsigned { return w = i; } + inline auto operator |= (unsigned i) -> unsigned { return w |= i; } + inline auto operator ^= (unsigned i) -> unsigned { return w ^= i; } + inline auto operator &= (unsigned i) -> unsigned { return w &= i; } + inline auto operator <<= (unsigned i) -> unsigned { return w <<= i; } + inline auto operator >>= (unsigned i) -> unsigned { return w >>= i; } + inline auto operator += (unsigned i) -> unsigned { return w += i; } + inline auto operator -= (unsigned i) -> unsigned { return w -= i; } + inline auto operator *= (unsigned i) -> unsigned { return w *= i; } + inline auto operator /= (unsigned i) -> unsigned { return w /= i; } + inline auto operator %= (unsigned i) -> unsigned { return w %= i; } }; struct reg24_t { union { - uint32 d; + uint32 d = 0; struct { uint16 order_lsb2(w, wh); }; struct { uint8 order_lsb4(l, h, b, bh); }; }; inline operator unsigned() const { return d; } - inline unsigned operator = (unsigned i) { return d = uclip<24>(i); } - inline unsigned operator |= (unsigned i) { return d = uclip<24>(d | i); } - inline unsigned operator ^= (unsigned i) { return d = uclip<24>(d ^ i); } - inline unsigned operator &= (unsigned i) { return d = uclip<24>(d & i); } - inline unsigned operator <<= (unsigned i) { return d = uclip<24>(d << i); } - inline unsigned operator >>= (unsigned i) { return d = uclip<24>(d >> i); } - inline unsigned operator += (unsigned i) { return d = uclip<24>(d + i); } - inline unsigned operator -= (unsigned i) { return d = uclip<24>(d - i); } - inline unsigned operator *= (unsigned i) { return d = uclip<24>(d * i); } - inline unsigned operator /= (unsigned i) { return d = uclip<24>(d / i); } - inline unsigned operator %= (unsigned i) { return d = uclip<24>(d % i); } - - reg24_t() : d(0) {} + inline auto operator = (unsigned i) -> unsigned { return d = uclip<24>(i); } + inline auto operator |= (unsigned i) -> unsigned { return d = uclip<24>(d | i); } + inline auto operator ^= (unsigned i) -> unsigned { return d = uclip<24>(d ^ i); } + inline auto operator &= (unsigned i) -> unsigned { return d = uclip<24>(d & i); } + inline auto operator <<= (unsigned i) -> unsigned { return d = uclip<24>(d << i); } + inline auto operator >>= (unsigned i) -> unsigned { return d = uclip<24>(d >> i); } + inline auto operator += (unsigned i) -> unsigned { return d = uclip<24>(d + i); } + inline auto operator -= (unsigned i) -> unsigned { return d = uclip<24>(d - i); } + inline auto operator *= (unsigned i) -> unsigned { return d = uclip<24>(d * i); } + inline auto operator /= (unsigned i) -> unsigned { return d = uclip<24>(d / i); } + inline auto operator %= (unsigned i) -> unsigned { return d = uclip<24>(d % i); } }; struct regs_t { reg24_t pc; - reg16_t r[6], &a, &x, &y, &z, &s, &d; + reg16_t a; + reg16_t x; + reg16_t y; + reg16_t z; //pseudo-register (zero register) + reg16_t s; + reg16_t d; flag_t p; - uint8 db; - bool e; + uint8 db{0}; + bool e{0}; - bool irq; //IRQ pin (0 = low, 1 = trigger) - bool wai; //raised during wai, cleared after interrupt triggered - uint8 mdr; //memory data register - uint16 vector; //interrupt vector address - - regs_t(): - a(r[0]), x(r[1]), y(r[2]), z(r[3]), s(r[4]), d(r[5]), db(0), e(false), irq(false), wai(false), mdr(0), vector(0) { - z = 0; - } + bool irq{0}; //IRQ pin (0 = low, 1 = trigger) + bool wai{0}; //raised during wai, cleared after interrupt triggered + uint8 mdr{0}; //memory data register + uint16 vector{0}; //interrupt vector address }; diff --git a/processor/r65816/serialization.cpp b/processor/r65816/serialization.cpp index 62df5ff5..9a100268 100644 --- a/processor/r65816/serialization.cpp +++ b/processor/r65816/serialization.cpp @@ -1,4 +1,4 @@ -void R65816::serialize(serializer& s) { +auto R65816::serialize(serializer& s) -> void { s.integer(regs.pc.d); s.integer(regs.a.w); @@ -28,6 +28,4 @@ void R65816::serialize(serializer& s) { s.integer(rd.d); s.integer(sp); s.integer(dp); - - update_table(); } diff --git a/processor/r65816/switch.cpp b/processor/r65816/switch.cpp new file mode 100644 index 00000000..4448244c --- /dev/null +++ b/processor/r65816/switch.cpp @@ -0,0 +1,292 @@ +auto R65816::op_exec() -> void { + #define opA( n, o ) case n: return op_##o(); + #define opAII(n, o, i, j) case n: return op_##o(i, j); + #define opE( n, o ) case n: return regs.e ? op_##o##_e() : op_##o##_n(); + #define opEI( n, o, i ) case n: return regs.e ? op_##o##_e(i) : op_##o##_n(i); + #define opEII(n, o, i, j) case n: return regs.e ? op_##o##_e(i) : op_##o##_n(j); + #define opM( n, o ) case n: return regs.p.m ? op_##o##_b() : op_##o##_w(); + #define opMF( n, o, f ) case n: return regs.p.m ? op_##o##_b(&R65816::op_##f##_b) : op_##o##_w(&R65816::op_##f##_w); + #define opMFI(n, o, f, i) case n: return regs.p.m ? op_##o##_b(&R65816::op_##f##_b, i) : op_##o##_w(&R65816::op_##f##_w, i); + #define opMI( n, o, i ) case n: return regs.p.m ? op_##o##_b(i) : op_##o##_w(i); + #define opMII(n, o, i, j) case n: return regs.p.m ? op_##o##_b(i, j) : op_##o##_w(i, j); + #define opX( n, o) case n: return regs.p.x ? op_##o##_b() : op_##o##_w(); + #define opXF( n, o, f ) case n: return regs.p.x ? op_##o##_b(&R65816::op_##f##_b) : op_##o##_w(&R65816::op_##f##_w); + #define opXFI(n, o, f, i) case n: return regs.p.x ? op_##o##_b(&R65816::op_##f##_b, i) : op_##o##_w(&R65816::op_##f##_w, i); + #define opXI( n, o, i ) case n: return regs.p.x ? op_##o##_b(i) : op_##o##_w(i); + #define opXII(n, o, i, j) case n: return regs.p.x ? op_##o##_b(i, j) : op_##o##_w(i, j); + + switch(op_readpc()) { + opEII(0x00, interrupt, 0xfffe, 0xffe6) + opMF (0x01, read_idpx, ora) + opEII(0x02, interrupt, 0xfff4, 0xffe4) + opMF (0x03, read_sr, ora) + opMF (0x04, adjust_dp, tsb) + opMF (0x05, read_dp, ora) + opMF (0x06, adjust_dp, asl) + opMF (0x07, read_ildp, ora) + opA (0x08, php) + opMF (0x09, read_const, ora) + opM (0x0a, asl_imm) + opE (0x0b, phd) + opMF (0x0c, adjust_addr, tsb) + opMF (0x0d, read_addr, ora) + opMF (0x0e, adjust_addr, asl) + opMF (0x0f, read_long, ora) + opAII(0x10, branch, regs.p.n, 0) + opMF (0x11, read_idpy, ora) + opMF (0x12, read_idp, ora) + opMF (0x13, read_isry, ora) + opMF (0x14, adjust_dp, trb) + opMFI(0x15, read_dpr, ora, regs.x) + opMF (0x16, adjust_dpx, asl) + opMF (0x17, read_ildpy, ora) + opAII(0x18, flag, regs.p.c, 0) + opMF (0x19, read_addry, ora) + opMII(0x1a, adjust_imm, regs.a, +1) + opE (0x1b, tcs) + opMF (0x1c, adjust_addr, trb) + opMF (0x1d, read_addrx, ora) + opMF (0x1e, adjust_addrx, asl) + opMF (0x1f, read_longx, ora) + opA (0x20, jsr_addr) + opMF (0x21, read_idpx, and) + opE (0x22, jsr_long) + opMF (0x23, read_sr, and) + opMF (0x24, read_dp, bit) + opMF (0x25, read_dp, and) + opMF (0x26, adjust_dp, rol) + opMF (0x27, read_ildp, and) + opE (0x28, plp) + opMF (0x29, read_const, and) + opM (0x2a, rol_imm) + opE (0x2b, pld) + opMF (0x2c, read_addr, bit) + opMF (0x2d, read_addr, and) + opMF (0x2e, adjust_addr, rol) + opMF (0x2f, read_long, and) + opAII(0x30, branch, regs.p.n, 1) + opMF (0x31, read_idpy, and) + opMF (0x32, read_idp, and) + opMF (0x33, read_isry, and) + opMFI(0x34, read_dpr, bit, regs.x) + opMFI(0x35, read_dpr, and, regs.x) + opMF (0x36, adjust_dpx, rol) + opMF (0x37, read_ildpy, and) + opAII(0x38, flag, regs.p.c, 1) + opMF (0x39, read_addry, and) + opMII(0x3a, adjust_imm, regs.a, -1) + opAII(0x3b, transfer_w, regs.s, regs.a) + opMF (0x3c, read_addrx, bit) + opMF (0x3d, read_addrx, and) + opMF (0x3e, adjust_addrx, rol) + opMF (0x3f, read_longx, and) + opE (0x40, rti) + opMF (0x41, read_idpx, eor) + opA (0x42, wdm) + opMF (0x43, read_sr, eor) + opXI (0x44, move, -1) + opMF (0x45, read_dp, eor) + opMF (0x46, adjust_dp, lsr) + opMF (0x47, read_ildp, eor) + opMI (0x48, push, regs.a) + opMF (0x49, read_const, eor) + opM (0x4a, lsr_imm) + opA (0x4b, phk) + opA (0x4c, jmp_addr) + opMF (0x4d, read_addr, eor) + opMF (0x4e, adjust_addr, lsr) + opMF (0x4f, read_long, eor) + opAII(0x50, branch, regs.p.v, 0) + opMF (0x51, read_idpy, eor) + opMF (0x52, read_idp, eor) + opMF (0x53, read_isry, eor) + opXI (0x54, move, +1) + opMFI(0x55, read_dpr, eor, regs.x) + opMF (0x56, adjust_dpx, lsr) + opMF (0x57, read_ildpy, eor) + opAII(0x58, flag, regs.p.i, 0) + opMF (0x59, read_addry, eor) + opXI (0x5a, push, regs.y) + opAII(0x5b, transfer_w, regs.a, regs.d) + opA (0x5c, jmp_long) + opMF (0x5d, read_addrx, eor) + opMF (0x5e, adjust_addrx, lsr) + opMF (0x5f, read_longx, eor) + opA (0x60, rts) + opMF (0x61, read_idpx, adc) + opE (0x62, per) + opMF (0x63, read_sr, adc) + opMI (0x64, write_dp, regs.z) + opMF (0x65, read_dp, adc) + opMF (0x66, adjust_dp, ror) + opMF (0x67, read_ildp, adc) + opMI (0x68, pull, regs.a) + opMF (0x69, read_const, adc) + opM (0x6a, ror_imm) + opE (0x6b, rtl) + opA (0x6c, jmp_iaddr) + opMF (0x6d, read_addr, adc) + opMF (0x6e, adjust_addr, ror) + opMF (0x6f, read_long, adc) + opAII(0x70, branch, regs.p.v, 1) + opMF (0x71, read_idpy, adc) + opMF (0x72, read_idp, adc) + opMF (0x73, read_isry, adc) + opMII(0x74, write_dpr, regs.z, regs.x) + opMFI(0x75, read_dpr, adc, regs.x) + opMF (0x76, adjust_dpx, ror) + opMF (0x77, read_ildpy, adc) + opAII(0x78, flag, regs.p.i, 1) + opMF (0x79, read_addry, adc) + opXI (0x7a, pull, regs.y) + opAII(0x7b, transfer_w, regs.d, regs.a) + opA (0x7c, jmp_iaddrx) + opMF (0x7d, read_addrx, adc) + opMF (0x7e, adjust_addrx, ror) + opMF (0x7f, read_longx, adc) + opA (0x80, bra) + opM (0x81, sta_idpx) + opA (0x82, brl) + opM (0x83, sta_sr) + opXI (0x84, write_dp, regs.y) + opMI (0x85, write_dp, regs.a) + opXI (0x86, write_dp, regs.x) + opM (0x87, sta_ildp) + opXII(0x88, adjust_imm, regs.y, -1) + opM (0x89, read_bit_const) + opMII(0x8a, transfer, regs.x, regs.a) + opA (0x8b, phb) + opXI (0x8c, write_addr, regs.y) + opMI (0x8d, write_addr, regs.a) + opXI (0x8e, write_addr, regs.x) + opMI (0x8f, write_longr, regs.z) + opAII(0x90, branch, regs.p.c, 0) + opM (0x91, sta_idpy) + opM (0x92, sta_idp) + opM (0x93, sta_isry) + opXII(0x94, write_dpr, regs.y, regs.x) + opMII(0x95, write_dpr, regs.a, regs.x) + opXII(0x96, write_dpr, regs.x, regs.y) + opM (0x97, sta_ildpy) + opMII(0x98, transfer, regs.y, regs.a) + opMII(0x99, write_addrr, regs.a, regs.y) + opE (0x9a, txs) + opXII(0x9b, transfer, regs.x, regs.y) + opMI (0x9c, write_addr, regs.z) + opMII(0x9d, write_addrr, regs.a, regs.x) + opMII(0x9e, write_addrr, regs.z, regs.x) + opMI (0x9f, write_longr, regs.x) + opXF (0xa0, read_const, ldy) + opMF (0xa1, read_idpx, lda) + opXF (0xa2, read_const, ldx) + opMF (0xa3, read_sr, lda) + opXF (0xa4, read_dp, ldy) + opMF (0xa5, read_dp, lda) + opXF (0xa6, read_dp, ldx) + opMF (0xa7, read_ildp, lda) + opXII(0xa8, transfer, regs.a, regs.y) + opMF (0xa9, read_const, lda) + opXII(0xaa, transfer, regs.a, regs.x) + opA (0xab, plb) + opXF (0xac, read_addr, ldy) + opMF (0xad, read_addr, lda) + opXF (0xae, read_addr, ldx) + opMF (0xaf, read_long, lda) + opAII(0xb0, branch, regs.p.c, 1) + opMF (0xb1, read_idpy, lda) + opMF (0xb2, read_idp, lda) + opMF (0xb3, read_isry, lda) + opXFI(0xb4, read_dpr, ldy, regs.x) + opMFI(0xb5, read_dpr, lda, regs.x) + opXFI(0xb6, read_dpr, ldx, regs.y) + opMF (0xb7, read_ildpy, lda) + opAII(0xb8, flag, regs.p.v, 0) + opMF (0xb9, read_addry, lda) + opX (0xba, tsx) + opXII(0xbb, transfer, regs.y, regs.x) + opXF (0xbc, read_addrx, ldy) + opMF (0xbd, read_addrx, lda) + opXF (0xbe, read_addry, ldx) + opMF (0xbf, read_longx, lda) + opXF (0xc0, read_const, cpy) + opMF (0xc1, read_idpx, cmp) + opEI (0xc2, pflag, 0) + opMF (0xc3, read_sr, cmp) + opXF (0xc4, read_dp, cpy) + opMF (0xc5, read_dp, cmp) + opMF (0xc6, adjust_dp, dec) + opMF (0xc7, read_ildp, cmp) + opXII(0xc8, adjust_imm, regs.y, +1) + opMF (0xc9, read_const, cmp) + opXII(0xca, adjust_imm, regs.x, -1) + opA (0xcb, wai) + opXF (0xcc, read_addr, cpy) + opMF (0xcd, read_addr, cmp) + opMF (0xce, adjust_addr, dec) + opMF (0xcf, read_long, cmp) + opAII(0xd0, branch, regs.p.z, 0) + opMF (0xd1, read_idpy, cmp) + opMF (0xd2, read_idp, cmp) + opMF (0xd3, read_isry, cmp) + opE (0xd4, pei) + opMFI(0xd5, read_dpr, cmp, regs.x) + opMF (0xd6, adjust_dpx, dec) + opMF (0xd7, read_ildpy, cmp) + opAII(0xd8, flag, regs.p.d, 0) + opMF (0xd9, read_addry, cmp) + opXI (0xda, push, regs.x) + opA (0xdb, stp) + opA (0xdc, jmp_iladdr) + opMF (0xdd, read_addrx, cmp) + opMF (0xde, adjust_addrx, dec) + opMF (0xdf, read_longx, cmp) + opXF (0xe0, read_const, cpx) + opMF (0xe1, read_idpx, sbc) + opEI (0xe2, pflag, 1) + opMF (0xe3, read_sr, sbc) + opXF (0xe4, read_dp, cpx) + opMF (0xe5, read_dp, sbc) + opMF (0xe6, adjust_dp, inc) + opMF (0xe7, read_ildp, sbc) + opXII(0xe8, adjust_imm, regs.x, +1) + opMF (0xe9, read_const, sbc) + opA (0xea, nop) + opA (0xeb, xba) + opXF (0xec, read_addr, cpx) + opMF (0xed, read_addr, sbc) + opMF (0xee, adjust_addr, inc) + opMF (0xef, read_long, sbc) + opAII(0xf0, branch, regs.p.z, 1) + opMF (0xf1, read_idpy, sbc) + opMF (0xf2, read_idp, sbc) + opMF (0xf3, read_isry, sbc) + opE (0xf4, pea) + opMFI(0xf5, read_dpr, sbc, regs.x) + opMF (0xf6, adjust_dpx, inc) + opMF (0xf7, read_ildpy, sbc) + opAII(0xf8, flag, regs.p.d, 1) + opMF (0xf9, read_addry, sbc) + opXI (0xfa, pull, regs.x) + opA (0xfb, xce) + opE (0xfc, jsr_iaddrx) + opMF (0xfd, read_addrx, sbc) + opMF (0xfe, adjust_addrx, inc) + opMF (0xff, read_longx, sbc) + } + + #undef opA + #undef opAII + #undef opE + #undef opEI + #undef opEII + #undef opM + #undef opMF + #undef opMFI + #undef opMI + #undef opMII + #undef opX + #undef opXF + #undef opXFI + #undef opXI + #undef opXII +} diff --git a/processor/r65816/table.cpp b/processor/r65816/table.cpp deleted file mode 100644 index 7a7a5e6c..00000000 --- a/processor/r65816/table.cpp +++ /dev/null @@ -1,308 +0,0 @@ -void R65816::initialize_opcode_table() { - #define opA( id, name ) op_table[table_EM + id] = op_table[table_MX + id] = op_table[table_Mx + id] = op_table[table_mX + id] = op_table[table_mx + id] = &R65816::op_##name; - #define opAII(id, name, x, y ) op_table[table_EM + id] = op_table[table_MX + id] = op_table[table_Mx + id] = op_table[table_mX + id] = op_table[table_mx + id] = &R65816::op_##name; - #define opE( id, name ) op_table[table_EM + id] = &R65816::op_##name##_e; op_table[table_MX + id] = op_table[table_Mx + id] = op_table[table_mX + id] = op_table[table_mx + id] = &R65816::op_##name##_n; - #define opEI( id, name, x ) op_table[table_EM + id] = &R65816::op_##name##_e; op_table[table_MX + id] = op_table[table_Mx + id] = op_table[table_mX + id] = op_table[table_mx + id] = &R65816::op_##name##_n; - #define opEII(id, name, x, y ) op_table[table_EM + id] = &R65816::op_##name##_e; op_table[table_MX + id] = op_table[table_Mx + id] = op_table[table_mX + id] = op_table[table_mx + id] = &R65816::op_##name##_n; - #define opM( id, name ) op_table[table_EM + id] = op_table[table_MX + id] = op_table[table_Mx + id] = &R65816::op_##name##_b; op_table[table_mX + id] = op_table[table_mx + id] = &R65816::op_##name##_w; - #define opMI( id, name, x ) op_table[table_EM + id] = op_table[table_MX + id] = op_table[table_Mx + id] = &R65816::op_##name##_b; op_table[table_mX + id] = op_table[table_mx + id] = &R65816::op_##name##_w; - #define opMII(id, name, x, y ) op_table[table_EM + id] = op_table[table_MX + id] = op_table[table_Mx + id] = &R65816::op_##name##_b; op_table[table_mX + id] = op_table[table_mx + id] = &R65816::op_##name##_w; - #define opMF( id, name, fn ) op_table[table_EM + id] = op_table[table_MX + id] = op_table[table_Mx + id] = &R65816::op_##name##_b<&R65816::op_##fn##_b>; op_table[table_mX + id] = op_table[table_mx + id] = &R65816::op_##name##_w<&R65816::op_##fn##_w>; - #define opMFI(id, name, fn, x) op_table[table_EM + id] = op_table[table_MX + id] = op_table[table_Mx + id] = &R65816::op_##name##_b<&R65816::op_##fn##_b, x>; op_table[table_mX + id] = op_table[table_mx + id] = &R65816::op_##name##_w<&R65816::op_##fn##_w, x>; - #define opX( id, name ) op_table[table_EM + id] = op_table[table_MX + id] = op_table[table_mX + id] = &R65816::op_##name##_b; op_table[table_Mx + id] = op_table[table_mx + id] = &R65816::op_##name##_w; - #define opXI( id, name, x ) op_table[table_EM + id] = op_table[table_MX + id] = op_table[table_mX + id] = &R65816::op_##name##_b; op_table[table_Mx + id] = op_table[table_mx + id] = &R65816::op_##name##_w; - #define opXII(id, name, x, y ) op_table[table_EM + id] = op_table[table_MX + id] = op_table[table_mX + id] = &R65816::op_##name##_b; op_table[table_Mx + id] = op_table[table_mx + id] = &R65816::op_##name##_w; - #define opXF( id, name, fn ) op_table[table_EM + id] = op_table[table_MX + id] = op_table[table_mX + id] = &R65816::op_##name##_b<&R65816::op_##fn##_b>; op_table[table_Mx + id] = op_table[table_mx + id] = &R65816::op_##name##_w<&R65816::op_##fn##_w>; - #define opXFI(id, name, fn, x) op_table[table_EM + id] = op_table[table_MX + id] = op_table[table_mX + id] = &R65816::op_##name##_b<&R65816::op_##fn##_b, x>; op_table[table_Mx + id] = op_table[table_mx + id] = &R65816::op_##name##_w<&R65816::op_##fn##_w, x>; - - opEII(0x00, interrupt, 0xfffe, 0xffe6) - opMF (0x01, read_idpx, ora) - opEII(0x02, interrupt, 0xfff4, 0xffe4) - opMF (0x03, read_sr, ora) - opMF (0x04, adjust_dp, tsb) - opMF (0x05, read_dp, ora) - opMF (0x06, adjust_dp, asl) - opMF (0x07, read_ildp, ora) - opA (0x08, php) - opMF (0x09, read_const, ora) - opM (0x0a, asl_imm) - opE (0x0b, phd) - opMF (0x0c, adjust_addr, tsb) - opMF (0x0d, read_addr, ora) - opMF (0x0e, adjust_addr, asl) - opMF (0x0f, read_long, ora) - opAII(0x10, branch, 0x80, false) - opMF (0x11, read_idpy, ora) - opMF (0x12, read_idp, ora) - opMF (0x13, read_isry, ora) - opMF (0x14, adjust_dp, trb) - opMFI(0x15, read_dpr, ora, X) - opMF (0x16, adjust_dpx, asl) - opMF (0x17, read_ildpy, ora) - opAII(0x18, flag, 0x01, 0x00) - opMF (0x19, read_addry, ora) - opMII(0x1a, adjust_imm, A, +1) - opE (0x1b, tcs) - opMF (0x1c, adjust_addr, trb) - opMF (0x1d, read_addrx, ora) - opMF (0x1e, adjust_addrx, asl) - opMF (0x1f, read_longx, ora) - opA (0x20, jsr_addr) - opMF (0x21, read_idpx, and) - opE (0x22, jsr_long) - opMF (0x23, read_sr, and) - opMF (0x24, read_dp, bit) - opMF (0x25, read_dp, and) - opMF (0x26, adjust_dp, rol) - opMF (0x27, read_ildp, and) - opE (0x28, plp) - opMF (0x29, read_const, and) - opM (0x2a, rol_imm) - opE (0x2b, pld) - opMF (0x2c, read_addr, bit) - opMF (0x2d, read_addr, and) - opMF (0x2e, adjust_addr, rol) - opMF (0x2f, read_long, and) - opAII(0x30, branch, 0x80, true) - opMF (0x31, read_idpy, and) - opMF (0x32, read_idp, and) - opMF (0x33, read_isry, and) - opMFI(0x34, read_dpr, bit, X) - opMFI(0x35, read_dpr, and, X) - opMF (0x36, adjust_dpx, rol) - opMF (0x37, read_ildpy, and) - opAII(0x38, flag, 0x01, 0x01) - opMF (0x39, read_addry, and) - opMII(0x3a, adjust_imm, A, -1) - opAII(0x3b, transfer_w, S, A) - opMF (0x3c, read_addrx, bit) - opMF (0x3d, read_addrx, and) - opMF (0x3e, adjust_addrx, rol) - opMF (0x3f, read_longx, and) - opE (0x40, rti) - opMF (0x41, read_idpx, eor) - opA (0x42, wdm) - opMF (0x43, read_sr, eor) - opXI (0x44, move, -1) - opMF (0x45, read_dp, eor) - opMF (0x46, adjust_dp, lsr) - opMF (0x47, read_ildp, eor) - opMI (0x48, push, A) - opMF (0x49, read_const, eor) - opM (0x4a, lsr_imm) - opA (0x4b, phk) - opA (0x4c, jmp_addr) - opMF (0x4d, read_addr, eor) - opMF (0x4e, adjust_addr, lsr) - opMF (0x4f, read_long, eor) - opAII(0x50, branch, 0x40, false) - opMF (0x51, read_idpy, eor) - opMF (0x52, read_idp, eor) - opMF (0x53, read_isry, eor) - opXI (0x54, move, +1) - opMFI(0x55, read_dpr, eor, X) - opMF (0x56, adjust_dpx, lsr) - opMF (0x57, read_ildpy, eor) - opAII(0x58, flag, 0x04, 0x00) - opMF (0x59, read_addry, eor) - opXI (0x5a, push, Y) - opAII(0x5b, transfer_w, A, D) - opA (0x5c, jmp_long) - opMF (0x5d, read_addrx, eor) - opMF (0x5e, adjust_addrx, lsr) - opMF (0x5f, read_longx, eor) - opA (0x60, rts) - opMF (0x61, read_idpx, adc) - opE (0x62, per) - opMF (0x63, read_sr, adc) - opMI (0x64, write_dp, Z) - opMF (0x65, read_dp, adc) - opMF (0x66, adjust_dp, ror) - opMF (0x67, read_ildp, adc) - opMI (0x68, pull, A) - opMF (0x69, read_const, adc) - opM (0x6a, ror_imm) - opE (0x6b, rtl) - opA (0x6c, jmp_iaddr) - opMF (0x6d, read_addr, adc) - opMF (0x6e, adjust_addr, ror) - opMF (0x6f, read_long, adc) - opAII(0x70, branch, 0x40, true) - opMF (0x71, read_idpy, adc) - opMF (0x72, read_idp, adc) - opMF (0x73, read_isry, adc) - opMII(0x74, write_dpr, Z, X) - opMFI(0x75, read_dpr, adc, X) - opMF (0x76, adjust_dpx, ror) - opMF (0x77, read_ildpy, adc) - opAII(0x78, flag, 0x04, 0x04) - opMF (0x79, read_addry, adc) - opXI (0x7a, pull, Y) - opAII(0x7b, transfer_w, D, A) - opA (0x7c, jmp_iaddrx) - opMF (0x7d, read_addrx, adc) - opMF (0x7e, adjust_addrx, ror) - opMF (0x7f, read_longx, adc) - opA (0x80, bra) - opM (0x81, sta_idpx) - opA (0x82, brl) - opM (0x83, sta_sr) - opXI (0x84, write_dp, Y) - opMI (0x85, write_dp, A) - opXI (0x86, write_dp, X) - opM (0x87, sta_ildp) - opXII(0x88, adjust_imm, Y, -1) - opM (0x89, read_bit_const) - opMII(0x8a, transfer, X, A) - opA (0x8b, phb) - opXI (0x8c, write_addr, Y) - opMI (0x8d, write_addr, A) - opXI (0x8e, write_addr, X) - opMI (0x8f, write_longr, Z) - opAII(0x90, branch, 0x01, false) - opM (0x91, sta_idpy) - opM (0x92, sta_idp) - opM (0x93, sta_isry) - opXII(0x94, write_dpr, Y, X) - opMII(0x95, write_dpr, A, X) - opXII(0x96, write_dpr, X, Y) - opM (0x97, sta_ildpy) - opMII(0x98, transfer, Y, A) - opMII(0x99, write_addrr, A, Y) - opE (0x9a, txs) - opXII(0x9b, transfer, X, Y) - opMI (0x9c, write_addr, Z) - opMII(0x9d, write_addrr, A, X) - opMII(0x9e, write_addrr, Z, X) - opMI (0x9f, write_longr, X) - opXF (0xa0, read_const, ldy) - opMF (0xa1, read_idpx, lda) - opXF (0xa2, read_const, ldx) - opMF (0xa3, read_sr, lda) - opXF (0xa4, read_dp, ldy) - opMF (0xa5, read_dp, lda) - opXF (0xa6, read_dp, ldx) - opMF (0xa7, read_ildp, lda) - opXII(0xa8, transfer, A, Y) - opMF (0xa9, read_const, lda) - opXII(0xaa, transfer, A, X) - opA (0xab, plb) - opXF (0xac, read_addr, ldy) - opMF (0xad, read_addr, lda) - opXF (0xae, read_addr, ldx) - opMF (0xaf, read_long, lda) - opAII(0xb0, branch, 0x01, true) - opMF (0xb1, read_idpy, lda) - opMF (0xb2, read_idp, lda) - opMF (0xb3, read_isry, lda) - opXFI(0xb4, read_dpr, ldy, X) - opMFI(0xb5, read_dpr, lda, X) - opXFI(0xb6, read_dpr, ldx, Y) - opMF (0xb7, read_ildpy, lda) - opAII(0xb8, flag, 0x40, 0x00) - opMF (0xb9, read_addry, lda) - opX (0xba, tsx) - opXII(0xbb, transfer, Y, X) - opXF (0xbc, read_addrx, ldy) - opMF (0xbd, read_addrx, lda) - opXF (0xbe, read_addry, ldx) - opMF (0xbf, read_longx, lda) - opXF (0xc0, read_const, cpy) - opMF (0xc1, read_idpx, cmp) - opEI (0xc2, pflag, 0) - opMF (0xc3, read_sr, cmp) - opXF (0xc4, read_dp, cpy) - opMF (0xc5, read_dp, cmp) - opMF (0xc6, adjust_dp, dec) - opMF (0xc7, read_ildp, cmp) - opXII(0xc8, adjust_imm, Y, +1) - opMF (0xc9, read_const, cmp) - opXII(0xca, adjust_imm, X, -1) - opA (0xcb, wai) - opXF (0xcc, read_addr, cpy) - opMF (0xcd, read_addr, cmp) - opMF (0xce, adjust_addr, dec) - opMF (0xcf, read_long, cmp) - opAII(0xd0, branch, 0x02, false) - opMF (0xd1, read_idpy, cmp) - opMF (0xd2, read_idp, cmp) - opMF (0xd3, read_isry, cmp) - opE (0xd4, pei) - opMFI(0xd5, read_dpr, cmp, X) - opMF (0xd6, adjust_dpx, dec) - opMF (0xd7, read_ildpy, cmp) - opAII(0xd8, flag, 0x08, 0x00) - opMF (0xd9, read_addry, cmp) - opXI (0xda, push, X) - opA (0xdb, stp) - opA (0xdc, jmp_iladdr) - opMF (0xdd, read_addrx, cmp) - opMF (0xde, adjust_addrx, dec) - opMF (0xdf, read_longx, cmp) - opXF (0xe0, read_const, cpx) - opMF (0xe1, read_idpx, sbc) - opEI (0xe2, pflag, 1) - opMF (0xe3, read_sr, sbc) - opXF (0xe4, read_dp, cpx) - opMF (0xe5, read_dp, sbc) - opMF (0xe6, adjust_dp, inc) - opMF (0xe7, read_ildp, sbc) - opXII(0xe8, adjust_imm, X, +1) - opMF (0xe9, read_const, sbc) - opA (0xea, nop) - opA (0xeb, xba) - opXF (0xec, read_addr, cpx) - opMF (0xed, read_addr, sbc) - opMF (0xee, adjust_addr, inc) - opMF (0xef, read_long, sbc) - opAII(0xf0, branch, 0x02, true) - opMF (0xf1, read_idpy, sbc) - opMF (0xf2, read_idp, sbc) - opMF (0xf3, read_isry, sbc) - opE (0xf4, pea) - opMFI(0xf5, read_dpr, sbc, X) - opMF (0xf6, adjust_dpx, inc) - opMF (0xf7, read_ildpy, sbc) - opAII(0xf8, flag, 0x08, 0x08) - opMF (0xf9, read_addry, sbc) - opXI (0xfa, pull, X) - opA (0xfb, xce) - opE (0xfc, jsr_iaddrx) - opMF (0xfd, read_addrx, sbc) - opMF (0xfe, adjust_addrx, inc) - opMF (0xff, read_longx, sbc) - - #undef opA - #undef opAII - #undef opE - #undef opEI - #undef opEII - #undef opM - #undef opMI - #undef opMII - #undef opMF - #undef opMFI - #undef opX - #undef opXI - #undef opXII - #undef opXF - #undef opXFI -} - -void R65816::update_table() { - if(regs.e) { - opcode_table = &op_table[table_EM]; - } else if(regs.p.m) { - if(regs.p.x) { - opcode_table = &op_table[table_MX]; - } else { - opcode_table = &op_table[table_Mx]; - } - } else { - if(regs.p.x) { - opcode_table = &op_table[table_mX]; - } else { - opcode_table = &op_table[table_mx]; - } - } -} diff --git a/ruby/input/shared/rawinput.cpp b/ruby/input/shared/rawinput.cpp index a1798501..9cc9de16 100644 --- a/ruby/input/shared/rawinput.cpp +++ b/ruby/input/shared/rawinput.cpp @@ -4,9 +4,6 @@ auto CALLBACK RawInputWindowProc(HWND, UINT, WPARAM, LPARAM) -> LRESULT; struct RawInput { - Input& input; - RawInput(Input& input) : input(input) {} - HANDLE mutex = nullptr; HWND hwnd = nullptr; bool ready = false; diff --git a/ruby/input/udev.cpp b/ruby/input/udev.cpp index 576381fa..26f54d62 100644 --- a/ruby/input/udev.cpp +++ b/ruby/input/udev.cpp @@ -12,12 +12,12 @@ #include "mouse/xlib.cpp" #include "joypad/udev.cpp" -struct InputUdev : input { +struct InputUdev : Input { InputKeyboardXlib xlibKeyboard; InputMouseXlib xlibMouse; InputJoypadUdev udev; - Input() : xlibKeyboard(*this), xlibMouse(*this), udev(*this) {} - ~Input() { term(); } + InputUdev() : xlibKeyboard(*this), xlibMouse(*this), udev(*this) {} + ~InputUdev() { term(); } struct Settings { uintptr_t handle = 0; diff --git a/ruby/input/windows.cpp b/ruby/input/windows.cpp index d0aadb85..9d181f1b 100644 --- a/ruby/input/windows.cpp +++ b/ruby/input/windows.cpp @@ -103,7 +103,3 @@ struct InputWindows : Input { if(directinputContext) { directinputContext->Release(); directinputContext = nullptr; } } }; - -DeclareInput(Windows) - -} diff --git a/ruby/ruby.cpp b/ruby/ruby.cpp index b1628cce..aea7688a 100644 --- a/ruby/ruby.cpp +++ b/ruby/ruby.cpp @@ -8,16 +8,16 @@ using namespace ruby; #undef mkdir #undef usleep -#if defined(PLATFORM_XORG) +#if defined(DISPLAY_XORG) #include #include #include -#elif defined(PLATFORM_MACOSX) +#elif defined(DISPLAY_QUARTZ) #define decimal CocoaDecimal #include #include #undef decimal -#elif defined(PLATFORM_WINDOWS) +#elif defined(DISPLAY_WINDOWS) #include #endif diff --git a/ruby/video/opengl/bind.hpp b/ruby/video/opengl/bind.hpp index e30d53b3..e65bf0d7 100644 --- a/ruby/video/opengl/bind.hpp +++ b/ruby/video/opengl/bind.hpp @@ -1,8 +1,4 @@ -#if defined(PLATFORM_MACOSX) -static bool OpenGLBind() { - return true; -} -#else +#if defined(DISPLAY_WINDOWS) || defined(DISPLAY_XORG) PFNGLCREATEPROGRAMPROC glCreateProgram = nullptr; PFNGLDELETEPROGRAMPROC glDeleteProgram = nullptr; PFNGLUSEPROGRAMPROC glUseProgram = nullptr; @@ -43,12 +39,17 @@ PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers = nullptr; PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers = nullptr; PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer = nullptr; PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D = nullptr; +#endif +#if defined(DISPLAY_WINDOWS) +PFNGLACTIVETEXTUREPROC glActiveTexture = nullptr; +#endif static bool OpenGLBind() { #define bind(prototype, function) \ function = (prototype)glGetProcAddress(#function); \ if(function == nullptr) return false + #if defined(DISPLAY_WINDOWS) || defined(DISPLAY_XORG) bind(PFNGLCREATEPROGRAMPROC, glCreateProgram); bind(PFNGLDELETEPROGRAMPROC, glDeleteProgram); bind(PFNGLUSEPROGRAMPROC, glUseProgram); @@ -89,9 +90,12 @@ static bool OpenGLBind() { bind(PFNGLDELETEFRAMEBUFFERSPROC, glDeleteFramebuffers); bind(PFNGLBINDFRAMEBUFFERPROC, glBindFramebuffer); bind(PFNGLFRAMEBUFFERTEXTURE2DPROC, glFramebufferTexture2D); + #endif + #if defined(DISPLAY_WINDOWS) + bind(PFNGLACTIVETEXTUREPROC, glActiveTexture); + #endif #undef bind return true; } -#endif diff --git a/ruby/video/opengl/opengl.hpp b/ruby/video/opengl/opengl.hpp index da510ae4..a35bb8ba 100644 --- a/ruby/video/opengl/opengl.hpp +++ b/ruby/video/opengl/opengl.hpp @@ -1,11 +1,11 @@ -#if defined(PLATFORM_XORG) +#if defined(DISPLAY_XORG) #include #include #define glGetProcAddress(name) (*glXGetProcAddress)((const GLubyte*)(name)) -#elif defined(PLATFORM_MACOSX) +#elif defined(DISPLAY_QUARTZ) #include #include -#elif defined(PLATFORM_WINDOWS) +#elif defined(DISPLAY_WINDOWS) #include #include #define glGetProcAddress(name) wglGetProcAddress(name) diff --git a/sfc/alt/ppu-performance/screen/screen.cpp b/sfc/alt/ppu-performance/screen/screen.cpp index 622bb231..3ac78ecd 100644 --- a/sfc/alt/ppu-performance/screen/screen.cpp +++ b/sfc/alt/ppu-performance/screen/screen.cpp @@ -1,7 +1,7 @@ #ifdef PPU_CPP unsigned PPU::Screen::get_palette(unsigned color) { - #if defined(ARCH_LSB) + #if defined(ENDIAN_LSB) return ((uint16*)ppu.cgram)[color]; #else color <<= 1; diff --git a/sfc/chip/sa1/sa1.cpp b/sfc/chip/sa1/sa1.cpp index c77ba254..fbc6fcac 100644 --- a/sfc/chip/sa1/sa1.cpp +++ b/sfc/chip/sa1/sa1.cpp @@ -32,7 +32,7 @@ void SA1::enter() { continue; } - (this->*opcode_table[op_readpc()])(); + op_exec(); } } @@ -152,7 +152,6 @@ void SA1::reset() { regs.mdr = 0x00; regs.wai = false; regs.vector = 0x0000; - R65816::update_table(); status.tick_counter = 0; diff --git a/sfc/cpu/cpu.cpp b/sfc/cpu/cpu.cpp index 4aa60e8e..b583aba1 100644 --- a/sfc/cpu/cpu.cpp +++ b/sfc/cpu/cpu.cpp @@ -86,7 +86,7 @@ void CPU::enter() { void CPU::op_step() { debugger.op_exec(regs.pc.d); - (this->*opcode_table[op_readpc()])(); + op_exec(); } void CPU::enable() { @@ -141,7 +141,6 @@ void CPU::reset() { regs.mdr = 0x00; regs.wai = false; regs.vector = 0xfffc; //reset vector address - update_table(); mmio_reset(); dma_reset();