general clean-up

src/backend/Core.cpp

@@ -58,7 +58,6 @@ void Core::Run(float volumeL, float volumeR) {
   MMIO& mmio = mem.mmio;
   Registers& regs = cpu->regs;
 
-  Event event;
   for (int field = 0; field < mmio.vi.numFields; field++) {
     u32 frameCycles = 0;
     for (int i = 0; i < mmio.vi.numHalflines; i++) {

src/backend/core/Mem.cpp

@@ -5,6 +5,7 @@
 #include <backend/RomHelpers.hpp>
 #include <File.hpp>
 #include <unarr.h>
+#include <cassert>
 
 namespace n64 {
 Mem::Mem() : flash(saveData) {
@@ -527,18 +528,14 @@ void Mem::Write64(Registers& regs, u32 paddr, u64 val) {
   }
 }
 
-u32 Mem::BackupRead32(u32 addr) {
+u32 Mem::BackupRead32() const {
   switch(saveType) {
     case SAVE_NONE: return 0;
     case SAVE_EEPROM_4k: case SAVE_EEPROM_16k:
       Util::warn("Accessing cartridge backup type SAVE_EEPROM, returning 0 for word read");
       return 0;
     case SAVE_FLASH_1m:
-      if(flash.flash.is_mapped()) {
+      return flash.Read32();
-        return flash.Read32(addr);
-      } else {
-        Util::panic("Invalid backup Read32 if save data is not initialized");
-      }
     case SAVE_SRAM_256k:
       return 0xFFFFFFFF;
     default:
@@ -553,11 +550,7 @@ void Mem::BackupWrite32(u32 addr, u32 val) {
     case SAVE_EEPROM_4k: case SAVE_EEPROM_16k:
       Util::panic("Accessing cartridge with save type SAVE_EEPROM in write word");
     case SAVE_FLASH_1m:
-      if(flash.flash.is_mapped()) {
+      flash.Write32(addr, val);
-        flash.Write32(addr, val);
-      } else {
-        Util::panic("Invalid backup Write32 if save data is not initialized");
-      }
       break;
     case SAVE_SRAM_256k:
       break;
@@ -573,11 +566,7 @@ u8 Mem::BackupRead8(u32 addr) {
       Util::warn("Accessing cartridge backup type SAVE_EEPROM, returning 0 for word read");
       return 0;
     case SAVE_FLASH_1m:
-      if(flash.flash.is_mapped()) {
+      return flash.Read8(addr);
-        return flash.Read8(addr);
-      } else {
-        Util::panic("Invalid backup Read8 if save data is not initialized");
-      }
     case SAVE_SRAM_256k:
       if(saveData.is_mapped()) {
         assert(addr < saveData.size());
@@ -597,11 +586,7 @@ void Mem::BackupWrite8(u32 addr, u8 val) {
     case SAVE_EEPROM_4k: case SAVE_EEPROM_16k:
       Util::panic("Accessing cartridge with save type SAVE_EEPROM in write word");
     case SAVE_FLASH_1m:
-      if(flash.flash.is_mapped()) {
+      flash.Write8(addr, val);
-        flash.Write8(addr, val);
-      } else {
-        Util::panic("Invalid backup Write8 if save data is not initialized");
-      }
       break;
     case SAVE_SRAM_256k:
       if(saveData.is_mapped()) {

src/backend/core/Mem.hpp

@@ -71,100 +71,12 @@ struct Flash {
   void CommandSetWriteOffs(u32);
   void CommandWrite();
   void CommandRead();
-
+  std::vector<u8> Serialize();
-  FORCE_INLINE std::vector<u8> Serialize() {
+  void Deserialize(const std::vector<u8>& data);
-    std::vector<u8> res{};
+  void Write32(u32 index, u32 val);
-
+  void Write8(u32 index, u8 val);
-    res.resize(
+  u32 Read8(u32 index) const;
-      sizeof(state) +
+  u32 Read32() const;
-      sizeof(status) +
-      sizeof(eraseOffs) +
-      sizeof(writeOffs) +
-      128);
-
-    u32 index = 0;
-    memcpy(res.data() + index, &state, sizeof(state));
-    index += sizeof(state);
-    memcpy(res.data() + index, &status, sizeof(status));
-    index += sizeof(status);
-    memcpy(res.data() + index, &eraseOffs, sizeof(eraseOffs));
-    index += sizeof(eraseOffs);
-    memcpy(res.data() + index, &writeOffs, sizeof(writeOffs));
-    index += sizeof(writeOffs);
-    memcpy(res.data() + index, writeBuf, 128);
-
-    res.insert(res.begin(), flash.begin(), flash.end());
-
-    return res;
-  }
-
-  FORCE_INLINE void Deserialize(const std::vector<u8>& data) {
-    u32 index = 0;
-    memcpy(&state, data.data() + index, sizeof(state));
-    index += sizeof(state);
-    memcpy(&status, data.data() + index, sizeof(status));
-    index += sizeof(status);
-    memcpy(&eraseOffs, data.data() + index, sizeof(eraseOffs));
-    index += sizeof(eraseOffs);
-    memcpy(&writeOffs, data.data() + index, sizeof(writeOffs));
-    index += sizeof(writeOffs);
-    memcpy(writeBuf, data.data() + index, 128);
-  }
-
-  FORCE_INLINE void Write32(u32 index, u32 val) {
-    if(index > 0) {
-      u8 cmd = val >> 24;
-      switch(cmd) {
-        case FLASH_COMMAND_EXECUTE: CommandExecute(); break;
-        case FLASH_COMMAND_STATUS: CommandStatus(); break;
-        case FLASH_COMMAND_SET_ERASE_OFFSET: CommandSetEraseOffs(val); break;
-        case FLASH_COMMAND_ERASE: CommandErase(); break;
-        case FLASH_COMMAND_SET_WRITE_OFFSET: CommandSetWriteOffs(val); break;
-        case FLASH_COMMAND_WRITE: CommandWrite(); break;
-        case FLASH_COMMAND_READ: CommandRead(); break;
-        default: Util::warn("Invalid flash command: {:02X}", cmd);
-      }
-    } else {
-      status = val;
-      Util::warn("Write of {:08X} to flash status register", val);
-    }
-  }
-
-  FORCE_INLINE void Write8(u32 index, u8 val) {
-      switch(state) {
-        case FlashState::Idle: Util::panic("Invalid FlashState::Idle with Write8");
-        case FlashState::Status: Util::panic("Invalid FlashState::Status with Write8");
-        case FlashState::Erase: Util::panic("Invalid FlashState::Erase with Write8");
-        case FlashState::Write:
-          writeBuf[index] = val;
-          break;
-        case FlashState::Read: Util::panic("Invalid FlashState::Read with Write8");
-        default: Util::warn("Invalid flash state on Write8: {:02X}", static_cast<u8>(state));
-      }
-  }
-
-  FORCE_INLINE u32 Read8(u32 index) const {
-    switch (state) {
-      case Idle: Util::panic("Flash read byte while in state FLASH_STATE_IDLE");
-      case Write: Util::panic("Flash read byte while in state FLASH_STATE_WRITE");
-      case Read: {
-        u8 value = flash[index];
-        Util::debug("Flash read byte in state read: index {:08X} = {:02X}", index, value);
-        return value;
-      }
-      case Status: {
-        u32 offset = (7 - (index % 8)) * 8;
-        u8 value = (status >> offset) & 0xFF;
-        Util::debug("Flash read byte in state status: index {:08X} = {:02X}", index, value);
-        return value;
-      }
-      default: Util::panic("Flash read byte while in unknown state");
-    }
-  }
-
-  FORCE_INLINE u32 Read32(u32 index) const {
-    return status >> 32;
-  }
 };
 
 struct Mem {
@@ -191,7 +103,7 @@ struct Mem {
   void Write32(Registers&, u32, u32);
   void Write64(Registers&, u32, u64);
 
-  u32 BackupRead32(u32);
+  u32 BackupRead32() const;
   void BackupWrite32(u32, u32);
   u8 BackupRead8(u32);
   void BackupWrite8(u32, u8);

src/backend/core/mem/Flash.cpp

@@ -98,4 +98,99 @@ void Flash::CommandRead() {
   state = FlashState::Read;
   status = 0x11118004F0000000;
 }
+
+std::vector<u8> Flash::Serialize() {
+  std::vector<u8> res{};
+
+  res.resize(
+  sizeof(state) +
+  sizeof(status) +
+  sizeof(eraseOffs) +
+  sizeof(writeOffs) +
+  128);
+
+  u32 index = 0;
+  memcpy(res.data() + index, &state, sizeof(state));
+  index += sizeof(state);
+  memcpy(res.data() + index, &status, sizeof(status));
+  index += sizeof(status);
+  memcpy(res.data() + index, &eraseOffs, sizeof(eraseOffs));
+  index += sizeof(eraseOffs);
+  memcpy(res.data() + index, &writeOffs, sizeof(writeOffs));
+  index += sizeof(writeOffs);
+  memcpy(res.data() + index, writeBuf, 128);
+
+  return res;
+}
+
+void Flash::Deserialize(const std::vector<u8>& data) {
+  u32 index = 0;
+  memcpy(&state, data.data() + index, sizeof(state));
+  index += sizeof(state);
+  memcpy(&status, data.data() + index, sizeof(status));
+  index += sizeof(status);
+  memcpy(&eraseOffs, data.data() + index, sizeof(eraseOffs));
+  index += sizeof(eraseOffs);
+  memcpy(&writeOffs, data.data() + index, sizeof(writeOffs));
+  index += sizeof(writeOffs);
+  memcpy(writeBuf, data.data() + index, 128);
+}
+
+void Flash::Write32(u32 index, u32 val) {
+  if(index > 0) {
+    u8 cmd = val >> 24;
+    switch(cmd) {
+      case FLASH_COMMAND_EXECUTE: CommandExecute(); break;
+      case FLASH_COMMAND_STATUS: CommandStatus(); break;
+      case FLASH_COMMAND_SET_ERASE_OFFSET: CommandSetEraseOffs(val); break;
+      case FLASH_COMMAND_ERASE: CommandErase(); break;
+      case FLASH_COMMAND_SET_WRITE_OFFSET: CommandSetWriteOffs(val); break;
+      case FLASH_COMMAND_WRITE: CommandWrite(); break;
+      case FLASH_COMMAND_READ: CommandRead(); break;
+      default: Util::warn("Invalid flash command: {:02X}", cmd);
+    }
+  } else {
+    Util::warn("Flash Write of {:08X} @ {:08X}", val, index);
+  }
+}
+
+void Flash::Write8(u32 index, u8 val) {
+  switch(state) {
+    case FlashState::Idle: Util::panic("Invalid FlashState::Idle with Write8");
+    case FlashState::Status: Util::panic("Invalid FlashState::Status with Write8");
+    case FlashState::Erase: Util::panic("Invalid FlashState::Erase with Write8");
+    case FlashState::Write:
+      writeBuf[index] = val;
+      break;
+    case FlashState::Read: Util::panic("Invalid FlashState::Read with Write8");
+    default: Util::warn("Invalid flash state on Write8: {:02X}", static_cast<u8>(state));
+  }
+}
+
+u32 Flash::Read8(u32 index) const {
+  switch (state) {
+    case Idle: Util::panic("Flash read byte while in state FLASH_STATE_IDLE");
+    case Write: Util::panic("Flash read byte while in state FLASH_STATE_WRITE");
+    case Read: {
+      if(saveData.is_mapped()) {
+        u8 value = saveData[index];
+        Util::debug("Flash read byte in state read: index {:08X} = {:02X}", index, value);
+        return value;
+      } else {
+        Util::panic("Accessing flash when not mapped!");
+      }
+    }
+    case Status: {
+      u32 offset = (7 - (index % 8)) * 8;
+      u8 value = (status >> offset) & 0xFF;
+      Util::debug("Flash read byte in state status: index {:08X} = {:02X}", index, value);
+      return value;
+    }
+    default: Util::panic("Flash read byte while in unknown state");
+  }
+}
+
+u32 Flash::Read32() const {
+  return status >> 32;
+}
 }