From 97f8ea6cfd24ac23341d9e19bec4b487b978161c Mon Sep 17 00:00:00 2001 From: wheremyfoodat <44909372+wheremyfoodat@users.noreply.github.com> Date: Thu, 20 Jul 2023 13:50:32 +0300 Subject: [PATCH] Get our first AR code running --- include/action_replay.hpp | 25 +++++++++++++++-- include/cheats.hpp | 7 +++-- include/emulator.hpp | 2 +- src/core/action_replay.cpp | 57 +++++++++++++++++++++++++++++++++++++- src/core/cheats.cpp | 8 ++++-- src/emulator.cpp | 34 +++++++++++++---------- 6 files changed, 110 insertions(+), 23 deletions(-) diff --git a/include/action_replay.hpp b/include/action_replay.hpp index 4b5ab709..6c6a8ba2 100644 --- a/include/action_replay.hpp +++ b/include/action_replay.hpp @@ -3,9 +3,10 @@ #include #include "helpers.hpp" +#include "memory.hpp" class ActionReplay { - using Cheat = std::vector; // A cheat is really just a bunch of u32 opcodes + using Cheat = std::vector; // A cheat is really just a bunch of 64-bit opcodes neatly encoded into 32-bit chunks u32 offset1, offset2; // Memory offset registers. Non-persistent. u32 data1, data2; // Data offset registers. Non-persistent. @@ -14,9 +15,29 @@ class ActionReplay { // When an instruction does not specify which offset or data register to use, we use the "active" one // Which is by default #1 and may be changed by certain AR operations u32 *activeOffset, *activeData; + + // Program counter + u32 pc = 0; + Memory& mem; + + // Has the cheat ended? + bool running = false; + // Run 1 AR instruction + void runInstruction(const Cheat& cheat, u32 instruction); + + // Action Replay has a billion D-type opcodes so this handles all of them + void executeDType(const Cheat& cheat, u32 instruction); + + u8 read8(u32 addr); + u16 read16(u32 addr); + u32 read32(u32 addr); + + void write8(u32 addr, u8 value); + void write16(u32 addr, u16 value); + void write32(u32 addr, u32 value); public: - ActionReplay(); + ActionReplay(Memory& mem); void runCheat(const Cheat& cheat); void reset(); }; \ No newline at end of file diff --git a/include/cheats.hpp b/include/cheats.hpp index ca69fa33..d2ee8166 100644 --- a/include/cheats.hpp +++ b/include/cheats.hpp @@ -5,6 +5,9 @@ #include "action_replay.hpp" #include "helpers.hpp" +// Forward-declare this since it's just passed and we don't want to include memory.hpp and increase compile time +class Memory; + class Cheats { public: enum class CheatType { @@ -17,10 +20,10 @@ class Cheats { std::vector instructions; }; - Cheats(); + Cheats(Memory& mem); void addCheat(const Cheat& cheat); - void runCheats(); void reset(); + void run(); private: ActionReplay ar; // An ActionReplay cheat machine for executing CTRPF codes diff --git a/include/emulator.hpp b/include/emulator.hpp index 187d6eca..040b93b2 100644 --- a/include/emulator.hpp +++ b/include/emulator.hpp @@ -32,7 +32,7 @@ class Emulator { Memory memory; Kernel kernel; Crypto::AESEngine aesEngine; - ActionReplay cheats; + Cheats cheats; SDL_Window* window; diff --git a/src/core/action_replay.cpp b/src/core/action_replay.cpp index 293d879e..2153bd1a 100644 --- a/src/core/action_replay.cpp +++ b/src/core/action_replay.cpp @@ -1,6 +1,6 @@ #include "action_replay.hpp" -ActionReplay::ActionReplay() { reset(); } +ActionReplay::ActionReplay(Memory& mem) : mem(mem) { reset(); } void ActionReplay::reset() { // Default value of storage regs is 0 @@ -11,4 +11,59 @@ void ActionReplay::reset() { void ActionReplay::runCheat(const Cheat& cheat) { // Set offset and data registers to 0 at the start of a cheat data1 = data2 = offset1 = offset2 = 0; + pc = 0; + running = true; + + activeOffset = &offset1; + activeData = &data1; + + while (running) { + // See if we can fetch 1 64-bit opcode, otherwise we're out of bounds. Cheats seem to end when going out of bounds? + if (pc + 1 >= cheat.size()) { + return; + } + + // Fetch instruction + const u32 instruction = cheat[pc++]; + runInstruction(cheat, instruction); + } +} + +u8 ActionReplay::read8(u32 addr) { return mem.read8(addr); } +u16 ActionReplay::read16(u32 addr) { return mem.read16(addr); } +u32 ActionReplay::read32(u32 addr) { return mem.read32(addr); } + +void ActionReplay::write8(u32 addr, u8 value) { mem.write8(addr, value); } +void ActionReplay::write16(u32 addr, u16 value) { mem.write16(addr, value); } +void ActionReplay::write32(u32 addr, u32 value) { mem.write32(addr, value); } + +void ActionReplay::runInstruction(const Cheat& cheat, u32 instruction) { + // Top nibble determines the instruction type + const u32 type = instruction >> 28; + + switch (type) { + // 8 bit write to [XXXXXXX + offset] + case 0x2: { + const u32 baseAddr = Helpers::getBits<0, 28>(instruction); + const u8 value = u8(cheat[pc++]); + write8(baseAddr + *activeOffset, value); + break; + } + + // Less Than (YYYYYYYY < [XXXXXXX + offset]) + case 0x4: { + const u32 baseAddr = Helpers::getBits<0, 28>(instruction); + const u32 imm = cheat[pc++]; + const u32 value = read32(baseAddr + *activeOffset); + Helpers::panic("TODO: How do ActionReplay conditional blocks work?"); + break; + } + + case 0xD: executeDType(cheat, instruction); break; + default: Helpers::panic("Unimplemented ActionReplay instruction type %X", type); break; + } +} + +void ActionReplay::executeDType(const Cheat& cheat, u32 instruction) { + Helpers::panic("ActionReplay: Unimplemented d-type opcode: %08X", instruction); } \ No newline at end of file diff --git a/src/core/cheats.cpp b/src/core/cheats.cpp index 9443670e..fd772550 100644 --- a/src/core/cheats.cpp +++ b/src/core/cheats.cpp @@ -1,13 +1,15 @@ #include "cheats.hpp" -Cheats::Cheats() { reset(); } +Cheats::Cheats(Memory& mem) : ar(mem) { reset(); } void Cheats::reset() { cheats.clear(); // Unload loaded cheats - ar.reset(); // Reset AR boi + ar.reset(); // Reset ActionReplay } -void Cheats::runCheats() { +void Cheats::addCheat(const Cheat& cheat) { cheats.push_back(cheat); } + +void Cheats::run() { for (const Cheat& cheat : cheats) { switch (cheat.type) { case CheatType::ActionReplay: { diff --git a/src/emulator.cpp b/src/emulator.cpp index 75f8ab1c..ff9fc22f 100644 --- a/src/emulator.cpp +++ b/src/emulator.cpp @@ -16,7 +16,7 @@ __declspec(dllexport) DWORD AmdPowerXpressRequestHighPerformance = 1; Emulator::Emulator() : config(std::filesystem::current_path() / "config.toml"), kernel(cpu, memory, gpu), cpu(memory, kernel), gpu(memory, config), - memory(cpu.getTicksRef()) { + memory(cpu.getTicksRef()), cheats(memory) { if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS) < 0) { Helpers::panic("Failed to initialize SDL2"); } @@ -104,20 +104,9 @@ void Emulator::run() { #endif while (running) { + runFrame(); ServiceManager& srv = kernel.getServiceManager(); - if (romType != ROMType::None) { -#ifdef PANDA3DS_ENABLE_HTTP_SERVER - pollHttpServer(); -#endif - runFrame(); // Run 1 frame of instructions - gpu.display(); // Display graphics - - // Send VBlank interrupts - srv.sendGPUInterrupt(GPUInterrupt::VBlank0); - srv.sendGPUInterrupt(GPUInterrupt::VBlank1); - } - SDL_Event event; while (SDL_PollEvent(&event)) { namespace Keys = HID::Keys; @@ -344,7 +333,24 @@ void Emulator::run() { } } -void Emulator::runFrame() { cpu.runFrame(); } +void Emulator::runFrame() { + if (romType != ROMType::None) { +#ifdef PANDA3DS_ENABLE_HTTP_SERVER + pollHttpServer(); +#endif + cpu.runFrame(); // Run 1 frame of instructions + gpu.display(); // Display graphics + + // Send VBlank interrupts + ServiceManager& srv = kernel.getServiceManager(); + srv.sendGPUInterrupt(GPUInterrupt::VBlank0); + srv.sendGPUInterrupt(GPUInterrupt::VBlank1); + + if (haveCheats) [[unlikely]] { + cheats.run(); + } + } +} bool Emulator::loadROM(const std::filesystem::path& path) { // Reset the emulator if we've already loaded a ROM