File melonds_PR1693.patch of Package melonds

Overview Repositories Revisions Requests Users Attributes Meta

File melonds_PR1693.patch of Package melonds (Revision d932b5faffaf790a907788760da81c73)

Currently displaying revision d932b5faffaf790a907788760da81c73 , Show latest

From 9bbd84ea44b16d7aab641a78fca6bf4dade49761 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Mon, 24 Apr 2023 14:02:01 -0400
Subject: [PATCH 01/22] Refactor Savestate::Var{8,16,32,64}

- They now delegate to VarArray
- They're declared in the class header so they're likely to be inlined
---
 src/Savestate.cpp | 56 -----------------------------------------------
 src/Savestate.h   | 23 +++++++++++++++----
 2 files changed, 19 insertions(+), 60 deletions(-)

diff --git a/src/Savestate.cpp b/src/Savestate.cpp
index 7a0961762..f3e1ba59a 100644
--- a/src/Savestate.cpp
+++ b/src/Savestate.cpp
@@ -211,62 +211,6 @@ void Savestate::Section(const char* magic)
     }
 }
 
-void Savestate::Var8(u8* var)
-{
-    if (Error) return;
-
-    if (Saving)
-    {
-        fwrite(var, 1, 1, file);
-    }
-    else
-    {
-        fread(var, 1, 1, file);
-    }
-}
-
-void Savestate::Var16(u16* var)
-{
-    if (Error) return;
-
-    if (Saving)
-    {
-        fwrite(var, 2, 1, file);
-    }
-    else
-    {
-        fread(var, 2, 1, file);
-    }
-}
-
-void Savestate::Var32(u32* var)
-{
-    if (Error) return;
-
-    if (Saving)
-    {
-        fwrite(var, 4, 1, file);
-    }
-    else
-    {
-        fread(var, 4, 1, file);
-    }
-}
-
-void Savestate::Var64(u64* var)
-{
-    if (Error) return;
-
-    if (Saving)
-    {
-        fwrite(var, 8, 1, file);
-    }
-    else
-    {
-        fread(var, 8, 1, file);
-    }
-}
-
 void Savestate::Bool32(bool* var)
 {
     // for compability
diff --git a/src/Savestate.h b/src/Savestate.h
index 51f071a93..2de49086a 100644
--- a/src/Savestate.h
+++ b/src/Savestate.h
@@ -42,10 +42,25 @@ class Savestate
 
     void Section(const char* magic);
 
-    void Var8(u8* var);
-    void Var16(u16* var);
-    void Var32(u32* var);
-    void Var64(u64* var);
+    void Var8(u8* var)
+    {
+        VarArray(var, sizeof(*var));
+    }
+
+    void Var16(u16* var)
+    {
+        VarArray(var, sizeof(*var));
+    }
+
+    void Var32(u32* var)
+    {
+        VarArray(var, sizeof(*var));
+    }
+
+    void Var64(u64* var)
+    {
+        VarArray(var, sizeof(*var));
+    }
 
     void Bool32(bool* var);

From cb84e81a76da304e165ee8863b6370286ce6f048 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Wed, 26 Apr 2023 18:56:04 -0400
Subject: [PATCH 02/22] First crack at refactoring Savestate to work in-memory

- Well, third, but who's counting?
---
 src/NDS.cpp       |   2 +
 src/Savestate.cpp | 291 ++++++++++++++++++++++++++++++----------------
 src/Savestate.h   |  32 ++++-
 3 files changed, 218 insertions(+), 107 deletions(-)

diff --git a/src/NDS.cpp b/src/NDS.cpp
index 215750f72..3548edbea 100644
--- a/src/NDS.cpp
+++ b/src/NDS.cpp
@@ -937,6 +937,8 @@ bool DoSavestate(Savestate* file)
     }
 #endif
 
+    file->Finish();
+
     return true;
 }
 
diff --git a/src/Savestate.cpp b/src/Savestate.cpp
index f3e1ba59a..b526c1627 100644
--- a/src/Savestate.cpp
+++ b/src/Savestate.cpp
@@ -17,12 +17,16 @@
 */
 
 #include <stdio.h>
+#include <cassert>
+#include <cstring>
 #include "Savestate.h"
 #include "Platform.h"
 
 using Platform::Log;
 using Platform::LogLevel;
 
+static const char* SAVESTATE_MAGIC = "MELN";
+
 /*
     Savestate format
 
@@ -46,64 +50,40 @@ using Platform::LogLevel;
     * different minor means adjustments may have to be made
 */
 
-// TODO: buffering system! or something of that sort
-// repeated fread/fwrite is slow on Switch
-
-Savestate::Savestate(std::string filename, bool save)
+Savestate::Savestate(void *buffer, u32 size, bool save) :
+    Error(false),
+    Saving(save),
+    VersionMajor(SAVESTATE_MAJOR),
+    VersionMinor(SAVESTATE_MINOR),
+    CurSection(NO_SECTION),
+    buffer(static_cast<u8 *>(buffer)),
+    buffer_offset(0),
+    buffer_length(size),
+    buffer_owned(false),
+    finished(false)
 {
-    const char* magic = "MELN";
-
-    Error = false;
-
-    if (save)
+    if (Saving)
     {
-        Saving = true;
-        file = Platform::OpenLocalFile(filename, "wb");
-        if (!file)
-        {
-            Log(LogLevel::Error, "savestate: file %s doesn't exist\n", filename.c_str());
-            Error = true;
-            return;
-        }
-
-        VersionMajor = SAVESTATE_MAJOR;
-        VersionMinor = SAVESTATE_MINOR;
-
-        fwrite(magic, 4, 1, file);
-        fwrite(&VersionMajor, 2, 1, file);
-        fwrite(&VersionMinor, 2, 1, file);
-        fseek(file, 8, SEEK_CUR); // length to be fixed later
+        WriteSavestateHeader();
     }
     else
     {
-        Saving = false;
-        file = Platform::OpenFile(filename, "rb");
-        if (!file)
-        {
-            Log(LogLevel::Error, "savestate: file %s doesn't exist\n", filename.c_str());
-            Error = true;
-            return;
-        }
-
-        u32 len;
-        fseek(file, 0, SEEK_END);
-        len = (u32)ftell(file);
-        fseek(file, 0, SEEK_SET);
-
-        u32 buf = 0;
+        // Ensure that the file starts with "MELN"
+        u32 read_magic = 0;
+        Var32(&read_magic);
 
-        fread(&buf, 4, 1, file);
-        if (buf != ((u32*)magic)[0])
+        if (read_magic != *((u32*)SAVESTATE_MAGIC))
         {
-            Log(LogLevel::Error, "savestate: invalid magic %08X\n", buf);
+            Log(LogLevel::Error, "savestate: expected magic number %#08x (%s), got %#08x\n",
+                *((u32*)SAVESTATE_MAGIC),
+                SAVESTATE_MAGIC,
+                read_magic
+            );
             Error = true;
             return;
         }
 
-        VersionMajor = 0;
-        VersionMinor = 0;
-
-        fread(&VersionMajor, 2, 1, file);
+        Var16(&VersionMajor);
         if (VersionMajor != SAVESTATE_MAJOR)
         {
             Log(LogLevel::Error, "savestate: bad version major %d, expecting %d\n", VersionMajor, SAVESTATE_MAJOR);
@@ -111,7 +91,7 @@ Savestate::Savestate(std::string filename, bool save)
             return;
         }
 
-        fread(&VersionMinor, 2, 1, file);
+        Var16(&VersionMinor);
         if (VersionMinor > SAVESTATE_MINOR)
         {
             Log(LogLevel::Error, "savestate: state from the future, %d > %d\n", VersionMinor, SAVESTATE_MINOR);
@@ -119,93 +99,111 @@ Savestate::Savestate(std::string filename, bool save)
             return;
         }
 
-        buf = 0;
-        fread(&buf, 4, 1, file);
-        if (buf != len)
+        u32 read_length = 0;
+        Var32(&read_length);
+        if (read_length != buffer_length)
         {
-            Log(LogLevel::Error, "savestate: bad length %d\n", buf);
+            Log(LogLevel::Error, "savestate: expected a length of %d, got %d\n", buffer_length, read_length);
             Error = true;
             return;
         }
 
-        fseek(file, 4, SEEK_CUR);
+        // The next 4 bytes are reserved
+        buffer_offset += 4;
     }
-
-    CurSection = -1;
 }
 
-Savestate::~Savestate()
+
+Savestate::Savestate(u32 initial_size) :
+    Error(false),
+    Saving(true), // Can't load from an empty buffer
+    VersionMajor(SAVESTATE_MAJOR),
+    VersionMinor(SAVESTATE_MINOR),
+    CurSection(NO_SECTION),
+    buffer(nullptr),
+    buffer_offset(0),
+    buffer_length(initial_size),
+    buffer_owned(true),
+    finished(false)
 {
-    if (Error) return;
+    buffer = static_cast<u8 *>(malloc(buffer_length));
 
-    if (Saving)
+    if (buffer == nullptr)
     {
-        if (CurSection != 0xFFFFFFFF)
-        {
-            u32 pos = (u32)ftell(file);
-            fseek(file, CurSection+4, SEEK_SET);
-
-            u32 len = pos - CurSection;
-            fwrite(&len, 4, 1, file);
+        Log(LogLevel::Error, "savestate: failed to allocate %d bytes\n", buffer_length);
+        Error = true;
+        return;
+    }
 
-            fseek(file, pos, SEEK_SET);
-        }
+    WriteSavestateHeader();
+}
 
-        fseek(file, 0, SEEK_END);
-        u32 len = (u32)ftell(file);
-        fseek(file, 8, SEEK_SET);
-        fwrite(&len, 4, 1, file);
+Savestate::~Savestate()
+{
+    if (Saving && !finished && !buffer_owned && !Error)
+    { // If we haven't finished saving, and there hasn't been an error...
+        CloseCurrentSection();
+        // No need to close the active section for an owned buffer,
+        // it's about to be thrown out.
     }
 
-    if (file) fclose(file);
+    if (buffer_owned)
+    {
+        free(buffer);
+    }
 }
 
 void Savestate::Section(const char* magic)
 {
-    if (Error) return;
+    if (Error || finished) return;
 
     if (Saving)
     {
-        if (CurSection != 0xFFFFFFFF)
-        {
-            u32 pos = (u32)ftell(file);
-            fseek(file, CurSection+4, SEEK_SET);
+        // Go back to the current section's header and write the length
+        CloseCurrentSection();
 
-            u32 len = pos - CurSection;
-            fwrite(&len, 4, 1, file);
+        CurSection = buffer_offset;
 
-            fseek(file, pos, SEEK_SET);
-        }
+        // Write the new section's magic number
+        VarArray((void*)magic, 4);
 
-        CurSection = (u32)ftell(file);
+        // The next 4 bytes are the length, which we'll come back to later.
+        u32 zero = 0;
+        Var32(&zero);
 
-        fwrite(magic, 4, 1, file);
-        fseek(file, 12, SEEK_CUR);
+        // The 8 bytes afterward are reserved, so we skip them.
+        Var32(&zero);
+        Var32(&zero);
     }
     else
     {
-        fseek(file, 0x10, SEEK_SET);
-
-        for (;;)
-        {
-            u32 buf = 0;
-
-            fread(&buf, 4, 1, file);
-            if (buf != ((u32*)magic)[0])
-            {
-                if (buf == 0)
-                {
+        // Start looking at the savestate's beginning, right after its header
+
+        for (u32 offset = 0x10;;)
+        { // Until we've found the desired section...
+            // Get this section's magic number
+            u32 read_magic = 0;
+            memcpy(&read_magic, buffer + offset, sizeof(read_magic));
+            offset += sizeof(read_magic);
+
+            if (read_magic != ((u32*)magic)[0])
+            { // If this isn't the right section...
+                if (offset >= buffer_length)
+                { // If we've reached the end of the file without finding this section...
                     Log(LogLevel::Error, "savestate: section %s not found. blarg\n", magic);
                     return;
                 }
 
-                buf = 0;
-                fread(&buf, 4, 1, file);
-                fseek(file, buf-8, SEEK_CUR);
+                // ...otherwise, let's keep looking
+                u32 read_length = 0;
+                memcpy(&read_length, buffer + offset, sizeof(read_length));
+
+                // Skip past the remainder of this section
+                offset += sizeof(read_length) + read_length - sizeof(read_length);
                 continue;
             }
 
-            fseek(file, 12, SEEK_CUR);
+            offset += 12; // Skip the extra 12 bytes we don't need
             break;
         }
     }
@@ -213,7 +211,7 @@ void Savestate::Section(const char* magic)
 
 void Savestate::Bool32(bool* var)
 {
-    // for compability
+    // for compatibility
     if (Saving)
     {
         u32 val = *var;
@@ -229,14 +227,101 @@ void Savestate::Bool32(bool* var)
 
 void Savestate::VarArray(void* data, u32 len)
 {
-    if (Error) return;
+    if (Error || finished) return;
+
+    assert(buffer_offset <= buffer_length);
 
     if (Saving)
     {
-        fwrite(data, len, 1, file);
+        if (buffer_offset + len > buffer_length)
+        { // If writing the given data would take us past the buffer's end...
+            Log(LogLevel::Warn, "savestate: %u-byte write would exceed %u-byte savestate buffer\n", len, buffer_length);
+
+            if (!(buffer_owned && Resize(buffer_length * 2 + len)))
+            { // If we're not allowed to resize this buffer, or if we are but failed...
+                Log(LogLevel::Error, "savestate: Failed to write %d bytes to savestate\n", len);
+                Error = true;
+                return;
+            }
+            // The buffer's length is doubled, plus however much memory is needed for this write.
+            // This way we can write the data and reduce the chance of needing to resize again.
+        }
+
+        memcpy(buffer + buffer_offset, data, len);
     }
     else
     {
-        fread(data, len, 1, file);
+        if (buffer_offset + len > buffer_length)
+        { // If reading the requested amount of data would take us past the buffer's edge...
+            Log(LogLevel::Error, "savestate: %u-byte read would exceed %u-byte savestate buffer\n", len, buffer_length);
+            Error = true;
+            return;
+
+            // Can't realloc here.
+            // Not only do we not own the buffer pointer (when loading a state),
+            // but we can't magically make the desired data appear.
+        }
+
+        memcpy(data, buffer + buffer_offset, len);
     }
+
+    buffer_offset += len;
+}
+
+void Savestate::CloseCurrentSection()
+{
+    if (CurSection != NO_SECTION)
+    { // If we're in the middle of writing a section...
+
+        // Go back to the section's header
+        // Get the length of the section we've written thus far
+        u32 section_length = buffer_offset - CurSection;
+
+        // Write the length in the section's header
+        // (specifically the first 4 bytes after the magic number)
+        memcpy(buffer + CurSection + 4, &section_length, sizeof(section_length));
+
+        CurSection = NO_SECTION;
+    }
+}
+
+bool Savestate::Resize(u32 new_length)
+{
+    if (!buffer_owned)
+    { // If we're not allowed to resize this buffer...
+        Log(LogLevel::Error, "savestate: Buffer is externally-owned, cannot resize it\n");
+        return false;
+    }
+
+    u32 old_length = buffer_length;
+    void* resized = realloc(buffer, new_length);
+    if (!resized)
+    { // If the buffer couldn't be expanded...
+        Log(LogLevel::Error, "savestate: Failed to resize owned savestate buffer from %dB to %dB\n", old_length, new_length);
+        return false;
+    }
+
+    u32 length_diff = new_length - old_length;
+    buffer = static_cast<u8 *>(resized);
+    buffer_length = new_length;
+
+    // Zero out the newly-allocated memory (to ensure we don't introduce a security hole)
+    memset(buffer + old_length, 0, length_diff);
+    return true;
+}
+
+void Savestate::WriteSavestateHeader()
+{// The magic number
+    VarArray((void *) SAVESTATE_MAGIC, 4);
+
+    // The major and minor versions
+    Var16(&VersionMajor);
+    Var16(&VersionMinor);
+
+    // The next 4 bytes are the file's length, which will be filled in at the end
+    u32 zero = 0;
+    Var32(&zero);
+
+    // The following 4 bytes are reserved
+    Var32(&zero);
 }
diff --git a/src/Savestate.h b/src/Savestate.h
index 2de49086a..670712c98 100644
--- a/src/Savestate.h
+++ b/src/Savestate.h
@@ -29,14 +29,18 @@
 class Savestate
 {
 public:
-    Savestate(std::string filename, bool save);
+    static constexpr u32 DEFAULT_SIZE = 16 * 1024 * 1024; // 16 MB
+    [[deprecated]] Savestate(std::string filename, bool save);
+    Savestate(void* buffer, u32 size, bool save);
+    Savestate(u32 initial_size = DEFAULT_SIZE);
+
     ~Savestate();
 
     bool Error;
 
     bool Saving;
-    u32 VersionMajor;
-    u32 VersionMinor;
+    u16 VersionMajor;
+    u16 VersionMinor;
 
     u32 CurSection;
 
@@ -66,6 +70,11 @@ class Savestate
 
     void VarArray(void* data, u32 len);
 
+    void Finish();
+
+    // TODO rewinds the stream
+    void Reset(bool save);
+
     bool IsAtleastVersion(u32 major, u32 minor)
     {
         if (VersionMajor > major) return true;
@@ -73,8 +82,23 @@ class Savestate
         return false;
     }
 
+    void* Buffer() { return buffer; }
+    [[nodiscard]] const void* Buffer() const { return buffer; }
+
+    [[nodiscard]] u32 BufferLength() const { return buffer_length; }
+
+    [[nodiscard]] u32 Length() const { return buffer_offset; }
+
 private:
-    FILE* file;
+    static constexpr u32 NO_SECTION = 0xffffffff;
+    void CloseCurrentSection();
+    bool Resize(u32 new_length);
+    void WriteSavestateHeader();
+    u8* buffer;
+    u32 buffer_offset;
+    u32 buffer_length;
+    bool buffer_owned;
+    bool finished;
 };
 
 #endif // SAVESTATE_H

From 5f1beef94d2404b85814439960fb1eea68e9637f Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Wed, 26 Apr 2023 18:58:22 -0400
Subject: [PATCH 03/22] Implement Savestate::Finish

---
 src/Savestate.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/Savestate.cpp b/src/Savestate.cpp
index b526c1627..004dc68bc 100644
--- a/src/Savestate.cpp
+++ b/src/Savestate.cpp
@@ -268,9 +268,15 @@ void Savestate::VarArray(void* data, u32 len)
     buffer_offset += len;
 }
 
+void Savestate::Finish()
+{
+    CloseCurrentSection();
+    finished = true;
+}
+
 void Savestate::CloseCurrentSection()
 {
-    if (CurSection != NO_SECTION)
+    if (CurSection != NO_SECTION && !finished)
     { // If we're in the middle of writing a section...
 
         // Go back to the section's header

From f5e3020c0122d766a076b0304f76756ce6376c24 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Wed, 26 Apr 2023 21:08:13 -0400
Subject: [PATCH 04/22] Remove the VersionMajor and VersionMinor fields

- Instead, pull their values directly from the savestate buffer
---
 src/Savestate.cpp | 25 +++++++++++++------------
 src/Savestate.h   | 23 +++++++++++++++++++----
 2 files changed, 32 insertions(+), 16 deletions(-)

diff --git a/src/Savestate.cpp b/src/Savestate.cpp
index 004dc68bc..e62ba0be3 100644
--- a/src/Savestate.cpp
+++ b/src/Savestate.cpp
@@ -53,8 +53,6 @@ static const char* SAVESTATE_MAGIC = "MELN";
 Savestate::Savestate(void *buffer, u32 size, bool save) :
     Error(false),
     Saving(save),
-    VersionMajor(SAVESTATE_MAJOR),
-    VersionMinor(SAVESTATE_MINOR),
     CurSection(NO_SECTION),
     buffer(static_cast<u8 *>(buffer)),
     buffer_offset(0),
@@ -83,18 +81,20 @@ Savestate::Savestate(void *buffer, u32 size, bool save) :
             return;
         }
 
-        Var16(&VersionMajor);
-        if (VersionMajor != SAVESTATE_MAJOR)
+        u16 major = 0;
+        Var16(&major);
+        if (major != SAVESTATE_MAJOR)
         {
-            Log(LogLevel::Error, "savestate: bad version major %d, expecting %d\n", VersionMajor, SAVESTATE_MAJOR);
+            Log(LogLevel::Error, "savestate: bad version major %d, expecting %d\n", major, SAVESTATE_MAJOR);
             Error = true;
             return;
         }
 
-        Var16(&VersionMinor);
-        if (VersionMinor > SAVESTATE_MINOR)
+        u16 minor = 0;
+        Var16(&minor);
+        if (minor > SAVESTATE_MINOR)
         {
-            Log(LogLevel::Error, "savestate: state from the future, %d > %d\n", VersionMinor, SAVESTATE_MINOR);
+            Log(LogLevel::Error, "savestate: state from the future, %d > %d\n", minor, SAVESTATE_MINOR);
             Error = true;
             return;
         }
@@ -117,8 +117,6 @@ Savestate::Savestate(void *buffer, u32 size, bool save) :
 Savestate::Savestate(u32 initial_size) :
     Error(false),
     Saving(true), // Can't load from an empty buffer
-    VersionMajor(SAVESTATE_MAJOR),
-    VersionMinor(SAVESTATE_MINOR),
     CurSection(NO_SECTION),
     buffer(nullptr),
     buffer_offset(0),
@@ -321,8 +319,11 @@ void Savestate::WriteSavestateHeader()
     VarArray((void *) SAVESTATE_MAGIC, 4);
 
     // The major and minor versions
-    Var16(&VersionMajor);
-    Var16(&VersionMinor);
+    u16 major = SAVESTATE_MAJOR;
+    Var16(&major);
+
+    u16 minor = SAVESTATE_MINOR;
+    Var16(&minor);
 
     // The next 4 bytes are the file's length, which will be filled in at the end
     u32 zero = 0;
diff --git a/src/Savestate.h b/src/Savestate.h
index 670712c98..6af3a84e3 100644
--- a/src/Savestate.h
+++ b/src/Savestate.h
@@ -39,8 +39,6 @@ class Savestate
     bool Error;
 
     bool Saving;
-    u16 VersionMajor;
-    u16 VersionMinor;
 
     u32 CurSection;
 
@@ -77,8 +75,9 @@ class Savestate
 
     bool IsAtleastVersion(u32 major, u32 minor)
     {
-        if (VersionMajor > major) return true;
-        if (VersionMajor == major && VersionMinor >= minor) return true;
+        u16 major_version = MajorVersion();
+        if (MajorVersion() > major) return true;
+        if (major_version == major && MinorVersion() >= minor) return true;
         return false;
     }
 
@@ -89,6 +88,22 @@ class Savestate
 
     [[nodiscard]] u32 Length() const { return buffer_offset; }
 
+    [[nodiscard]] u16 MajorVersion() const
+    {
+        // major version is stored at offset 0x04
+        u16 major = 0;
+        memcpy(&major, buffer + 0x04, sizeof(major));
+        return major;
+    }
+
+    [[nodiscard]] u16 MinorVersion() const
+    {
+        // minor version is stored at offset 0x06
+        u16 minor = 0;
+        memcpy(&minor, buffer + 0x06, sizeof(minor));
+        return minor;
+    }
+
 private:
     static constexpr u32 NO_SECTION = 0xffffffff;
     void CloseCurrentSection();

From 89c0d9d1535bf104a36af5f35ea211484b356871 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Wed, 26 Apr 2023 21:08:26 -0400
Subject: [PATCH 05/22] Mark a new constructor as explicit

---
 src/Savestate.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Savestate.h b/src/Savestate.h
index 6af3a84e3..6a82598c7 100644
--- a/src/Savestate.h
+++ b/src/Savestate.h
@@ -32,7 +32,7 @@ class Savestate
     static constexpr u32 DEFAULT_SIZE = 16 * 1024 * 1024; // 16 MB
     [[deprecated]] Savestate(std::string filename, bool save);
     Savestate(void* buffer, u32 size, bool save);
-    Savestate(u32 initial_size = DEFAULT_SIZE);
+    explicit Savestate(u32 initial_size = DEFAULT_SIZE);
 
     ~Savestate();

From 0b983c306bd331b68192ae800f2ea524c9b732ae Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Wed, 26 Apr 2023 21:08:40 -0400
Subject: [PATCH 06/22] Rename Reset to Rewind

---
 src/Savestate.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Savestate.h b/src/Savestate.h
index 6a82598c7..8207a9bc4 100644
--- a/src/Savestate.h
+++ b/src/Savestate.h
@@ -71,7 +71,7 @@ class Savestate
     void Finish();
 
     // TODO rewinds the stream
-    void Reset(bool save);
+    void Rewind(bool save);
 
     bool IsAtleastVersion(u32 major, u32 minor)
     {

From 1223381fed0eae808a71177d489cccece15daf20 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Wed, 26 Apr 2023 21:08:53 -0400
Subject: [PATCH 07/22] Fix a linebreak

---
 src/Savestate.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/Savestate.cpp b/src/Savestate.cpp
index e62ba0be3..7da061974 100644
--- a/src/Savestate.cpp
+++ b/src/Savestate.cpp
@@ -315,7 +315,8 @@ bool Savestate::Resize(u32 new_length)
 }
 
 void Savestate::WriteSavestateHeader()
-{// The magic number
+{
+    // The magic number
     VarArray((void *) SAVESTATE_MAGIC, 4);
 
     // The major and minor versions

From 9048c619234aa7f2e099603bb893846c863bda21 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Wed, 26 Apr 2023 21:09:02 -0400
Subject: [PATCH 08/22] Implement Savestate::Rewind

---
 src/Savestate.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/Savestate.cpp b/src/Savestate.cpp
index 7da061974..dfd3e5383 100644
--- a/src/Savestate.cpp
+++ b/src/Savestate.cpp
@@ -272,6 +272,16 @@ void Savestate::Finish()
     finished = true;
 }
 
+void Savestate::Rewind(bool save)
+{
+    Error = false;
+    Saving = save;
+    CurSection = NO_SECTION;
+
+    buffer_offset = 0;
+    finished = false;
+}
+
 void Savestate::CloseCurrentSection()
 {
     if (CurSection != NO_SECTION && !finished)

From a54f69d6ec54bb6917169af90897b3e7934d3b90 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Wed, 26 Apr 2023 21:09:25 -0400
Subject: [PATCH 09/22] Add ROMManager::ClearBackupState

---
 src/frontend/qt_sdl/ROMManager.cpp | 7 +++++++
 src/frontend/qt_sdl/ROMManager.h   | 1 +
 2 files changed, 8 insertions(+)

diff --git a/src/frontend/qt_sdl/ROMManager.cpp b/src/frontend/qt_sdl/ROMManager.cpp
index ac525b746..2da842db0 100644
--- a/src/frontend/qt_sdl/ROMManager.cpp
+++ b/src/frontend/qt_sdl/ROMManager.cpp
@@ -478,6 +478,13 @@ bool LoadBIOS()
     return true;
 }
 
+void ClearBackupState()
+{
+    if (BackupState != nullptr)
+    {
+        BackupState = nullptr;
+    }
+}
 
 bool LoadROM(QStringList filepath, bool reset)
 {
diff --git a/src/frontend/qt_sdl/ROMManager.h b/src/frontend/qt_sdl/ROMManager.h
index 9e82a5b14..bb6134302 100644
--- a/src/frontend/qt_sdl/ROMManager.h
+++ b/src/frontend/qt_sdl/ROMManager.h
@@ -35,6 +35,7 @@ extern SaveManager* GBASave;
 QString VerifySetup();
 void Reset();
 bool LoadBIOS();
+void ClearBackupState();
 
 bool LoadROM(QStringList filepath, bool reset);
 void EjectCart();

From d3774744416a917784a10a12ac1c3c0da9f72a50 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Wed, 26 Apr 2023 21:10:18 -0400
Subject: [PATCH 10/22] Refactor ROMManager to use the refactored Savestate

---
 src/frontend/qt_sdl/ROMManager.cpp | 105 ++++++++++++++++++++---------
 1 file changed, 74 insertions(+), 31 deletions(-)

diff --git a/src/frontend/qt_sdl/ROMManager.cpp b/src/frontend/qt_sdl/ROMManager.cpp
index 2da842db0..93550ec8c 100644
--- a/src/frontend/qt_sdl/ROMManager.cpp
+++ b/src/frontend/qt_sdl/ROMManager.cpp
@@ -21,6 +21,7 @@
 
 #include <string>
 #include <utility>
+#include <fstream>
 
 #ifdef ARCHIVE_SUPPORT_ENABLED
 #include "ArchiveUtil.h"
@@ -51,6 +52,7 @@ std::string BaseGBAAssetName = "";
 SaveManager* NDSSave = nullptr;
 SaveManager* GBASave = nullptr;
 
+std::unique_ptr<Savestate> BackupState = nullptr;
 bool SavestateLoaded = false;
 std::string PreviousSaveFile = "";
 
@@ -290,35 +292,51 @@ bool SavestateExists(int slot)
 
 bool LoadState(std::string filename)
 {
-    // backup
-    Savestate* backup = new Savestate("timewarp.mln", true);
-    NDS::DoSavestate(backup);
-    delete backup;
-
-    bool failed = false;
+    // We use unique_ptr and filebuf to mitigate resource leaks.
+    // (Arisotura is not the only derp here.)
+    // Now let's actually open the file...
+    std::basic_filebuf<u8> file;
+    if (!file.open(filename, std::ios::in | std::ios::binary))
+    { // If we couldn't open the state file...
+        Platform::Log(Platform::LogLevel::Error, "Failed to open state file %s\n", filename.c_str());
+        return false;
+    }
 
-    Savestate* state = new Savestate(filename, false);
-    if (state->Error)
-    {
-        delete state;
+    std::unique_ptr<Savestate> backup = std::make_unique<Savestate>(Savestate::DEFAULT_SIZE);
+    if (backup->Error)
+    { // If we couldn't allocate memory for the backup...
+        Platform::Log(Platform::LogLevel::Error, "Failed to allocate memory for state backup\n");
+        return false;
+    }
 
-        // current state might be crapoed, so restore from sane backup
-        state = new Savestate("timewarp.mln", false);
-        failed = true;
+    if (!NDS::DoSavestate(backup.get()) || backup->Error)
+    { // Back up the emulator's state. If that failed...
+        Platform::Log(Platform::LogLevel::Error, "Failed to back up state, aborting load (from %s)\n", filename.c_str());
+        return false;
     }
+    // We'll store the backup once we're sure that the state was loaded.
+    // Now that we know the file and backup are both good, let's load the new state.
 
-    bool res = NDS::DoSavestate(state);
-    delete state;
+    // Get the size of the file that we opened
+    std::streamsize size = file.pubseekoff(0, std::ios::end, std::ios::in);
+    file.pubseekpos(0, std::ios::in); // reset the filebuf's position
 
-    if (!res)
-    {
-        failed = true;
-        state = new Savestate("timewarp.mln", false);
-        NDS::DoSavestate(state);
-        delete state;
+    // Allocate exactly as much memory as we need for the savestate
+    std::vector<u8> buffer(size);
+    file.sgetn(buffer.data(), size); // read the file into the buffer
+
+    // Get ready to load the state from the buffer into the emulator
+    std::unique_ptr<Savestate> state = std::make_unique<Savestate>(buffer.data(), size, false);
+
+    if (!NDS::DoSavestate(state.get()) || state->Error)
+    { // If we couldn't load the savestate from the buffer...
+        Platform::Log(Platform::LogLevel::Error, "Failed to load state file %s into emulator\n", filename.c_str());
+        return false;
     }
 
-    if (failed) return false;
+    // The backup was made and the state was loaded, so we can store the backup now.
+    BackupState = std::move(backup); // This will clean up any existing backup
+    assert(backup == nullptr);
 
     if (Config::SavestateRelocSRAM && NDSSave)
     {
@@ -337,15 +355,40 @@ bool LoadState(std::string filename)
 
 bool SaveState(std::string filename)
 {
-    Savestate* state = new Savestate(filename, true);
-    if (state->Error)
+    std::basic_filebuf<u8> file;
+    // Using std::filebuf so that RAII will close the file
+
+    if (!file.open(filename, std::ios::out | std::ios::binary))
+    { // If the file couldn't be opened...
+        return false;
+    }
+
+    Savestate state;
+    if (state.Error)
+    { // If there was an error creating the state (and allocating its memory)...
+        return false;
+    }
+
+    // Write the savestate to the in-memory buffer
+    NDS::DoSavestate(&state);
+
+    if (state.Error)
     {
-        delete state;
         return false;
     }
 
-    NDS::DoSavestate(state);
-    delete state;
+    // Write the buffer to the file
+    u32 bytesWritten = file.sputn(static_cast<const u8*>(state.Buffer()), state.Length());
+    if (bytesWritten != state.Length())
+    {
+        Platform::Log(Platform::Error,
+            "Expected to write %d-byte savestate to %s, but only wrote %d bytes\n",
+            state.Length(),
+            filename.c_str(),
+            bytesWritten
+        );
+        return false;
+    }
 
     if (Config::SavestateRelocSRAM && NDSSave)
     {
@@ -360,14 +403,14 @@ bool SaveState(std::string filename)
 
 void UndoStateLoad()
 {
-    if (!SavestateLoaded) return;
+    if (!SavestateLoaded || !BackupState) return;
 
+    // Rewind the backup state and put it in load mode
+    BackupState->Rewind(false);
     // pray that this works
     // what do we do if it doesn't???
     // but it should work.
-    Savestate* backup = new Savestate("timewarp.mln", false);
-    NDS::DoSavestate(backup);
-    delete backup;
+    NDS::DoSavestate(BackupState.get());
 
     if (NDSSave && (!PreviousSaveFile.empty()))
     {

From f27892843d7121f35fa40fa4f6889ecf10fcc8c5 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Wed, 26 Apr 2023 21:11:32 -0400
Subject: [PATCH 11/22] Capitalize "Least"

- It was driving me nuts
---
 src/GPU3D.cpp   | 2 +-
 src/Savestate.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/GPU3D.cpp b/src/GPU3D.cpp
index 5c4857508..145b689f2 100644
--- a/src/GPU3D.cpp
+++ b/src/GPU3D.cpp
@@ -562,7 +562,7 @@ void DoSavestate(Savestate* file)
         file->Bool32(&poly->IsShadowMask);
         file->Bool32(&poly->IsShadow);
 
-        if (file->IsAtleastVersion(4, 1))
+        if (file->IsAtLeastVersion(4, 1))
             file->Var32((u32*)&poly->Type);
         else
             poly->Type = 0;
diff --git a/src/Savestate.h b/src/Savestate.h
index 8207a9bc4..4e3cae9bb 100644
--- a/src/Savestate.h
+++ b/src/Savestate.h
@@ -73,7 +73,7 @@ class Savestate
     // TODO rewinds the stream
     void Rewind(bool save);
 
-    bool IsAtleastVersion(u32 major, u32 minor)
+    bool IsAtLeastVersion(u32 major, u32 minor)
     {
         u16 major_version = MajorVersion();
         if (MajorVersion() > major) return true;

From f5ab09696b930deea2e1bbcd8bab2c26e4c1d329 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Wed, 26 Apr 2023 21:16:52 -0400
Subject: [PATCH 12/22] Add a log call

---
 src/Savestate.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Savestate.cpp b/src/Savestate.cpp
index dfd3e5383..98aa2888d 100644
--- a/src/Savestate.cpp
+++ b/src/Savestate.cpp
@@ -319,6 +319,7 @@ bool Savestate::Resize(u32 new_length)
     buffer = static_cast<u8 *>(resized);
     buffer_length = new_length;
 
+    Log(LogLevel::Debug, "savestate: Expanded %uB savestate buffer to %uB\n", old_length, new_length);
     // Zero out the newly-allocated memory (to ensure we don't introduce a security hole)
     memset(buffer + old_length, 0, length_diff);
     return true;

From 67a0cdb1e8b4524ad82e2fa8c96767b0783ddd43 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Wed, 26 Apr 2023 22:54:05 -0400
Subject: [PATCH 13/22] Increase default Savestate buffer length to 32MB

---
 src/Savestate.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Savestate.h b/src/Savestate.h
index 4e3cae9bb..184f6b539 100644
--- a/src/Savestate.h
+++ b/src/Savestate.h
@@ -29,7 +29,7 @@
 class Savestate
 {
 public:
-    static constexpr u32 DEFAULT_SIZE = 16 * 1024 * 1024; // 16 MB
+    static constexpr u32 DEFAULT_SIZE = 32 * 1024 * 1024; // 32 MB
     [[deprecated]] Savestate(std::string filename, bool save);
     Savestate(void* buffer, u32 size, bool save);
     explicit Savestate(u32 initial_size = DEFAULT_SIZE);

From 9cee99b233937a719772bd21ac8be8ef7329c16c Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Wed, 26 Apr 2023 22:55:10 -0400
Subject: [PATCH 14/22] Use C-style file I/O instead of C++-style

- Dumping bytes to a file with C++'s standard library is a MONSTROUS PAIN IN THE ASS
---
 src/frontend/qt_sdl/ROMManager.cpp | 48 +++++++++++++++++++-----------
 1 file changed, 30 insertions(+), 18 deletions(-)

diff --git a/src/frontend/qt_sdl/ROMManager.cpp b/src/frontend/qt_sdl/ROMManager.cpp
index 93550ec8c..189ce77a8 100644
--- a/src/frontend/qt_sdl/ROMManager.cpp
+++ b/src/frontend/qt_sdl/ROMManager.cpp
@@ -292,11 +292,8 @@ bool SavestateExists(int slot)
 
 bool LoadState(std::string filename)
 {
-    // We use unique_ptr and filebuf to mitigate resource leaks.
-    // (Arisotura is not the only derp here.)
-    // Now let's actually open the file...
-    std::basic_filebuf<u8> file;
-    if (!file.open(filename, std::ios::in | std::ios::binary))
+    FILE* file = fopen(filename.c_str(), "rb");
+    if (file == nullptr)
     { // If we couldn't open the state file...
         Platform::Log(Platform::LogLevel::Error, "Failed to open state file %s\n", filename.c_str());
         return false;
@@ -306,24 +303,38 @@ bool LoadState(std::string filename)
     if (backup->Error)
     { // If we couldn't allocate memory for the backup...
         Platform::Log(Platform::LogLevel::Error, "Failed to allocate memory for state backup\n");
+        fclose(file);
         return false;
     }
 
     if (!NDS::DoSavestate(backup.get()) || backup->Error)
     { // Back up the emulator's state. If that failed...
         Platform::Log(Platform::LogLevel::Error, "Failed to back up state, aborting load (from %s)\n", filename.c_str());
+        fclose(file);
         return false;
     }
     // We'll store the backup once we're sure that the state was loaded.
     // Now that we know the file and backup are both good, let's load the new state.
 
     // Get the size of the file that we opened
-    std::streamsize size = file.pubseekoff(0, std::ios::end, std::ios::in);
-    file.pubseekpos(0, std::ios::in); // reset the filebuf's position
+    if (fseek(file, 0, SEEK_END) != 0)
+    {
+        Platform::Log(Platform::LogLevel::Error, "Failed to seek to end of state file %s\n", filename.c_str());
+        fclose(file);
+        return false;
+    }
+    size_t size = ftell(file);
+    rewind(file); // reset the filebuf's position
 
     // Allocate exactly as much memory as we need for the savestate
     std::vector<u8> buffer(size);
-    file.sgetn(buffer.data(), size); // read the file into the buffer
+    if (fread(buffer.data(), size, 1, file) == 0)
+    { // Read the state file into the buffer. If that failed...
+        Platform::Log(Platform::LogLevel::Error, "Failed to read %u-byte state file %s\n", size, filename.c_str());
+        fclose(file);
+        return false;
+    }
+    fclose(file); // done with the file now
 
     // Get ready to load the state from the buffer into the emulator
     std::unique_ptr<Savestate> state = std::make_unique<Savestate>(buffer.data(), size, false);
@@ -355,10 +366,9 @@ bool LoadState(std::string filename)
 
 bool SaveState(std::string filename)
 {
-    std::basic_filebuf<u8> file;
-    // Using std::filebuf so that RAII will close the file
+    FILE* file = fopen(filename.c_str(), "wb");
 
-    if (!file.open(filename, std::ios::out | std::ios::binary))
+    if (file == nullptr)
     { // If the file couldn't be opened...
         return false;
     }
@@ -366,6 +376,7 @@ bool SaveState(std::string filename)
     Savestate state;
     if (state.Error)
     { // If there was an error creating the state (and allocating its memory)...
+        fclose(file);
         return false;
     }
 
@@ -374,22 +385,23 @@ bool SaveState(std::string filename)
 
     if (state.Error)
     {
+        fclose(file);
         return false;
     }
 
-    // Write the buffer to the file
-    u32 bytesWritten = file.sputn(static_cast<const u8*>(state.Buffer()), state.Length());
-    if (bytesWritten != state.Length())
-    {
+    if (fwrite(state.Buffer(), state.Length(), 1, file) == 0)
+    { // Write the Savestate buffer to the file. If that fails...
         Platform::Log(Platform::Error,
-            "Expected to write %d-byte savestate to %s, but only wrote %d bytes\n",
+            "Failed to write %d-byte savestate to %s\n",
             state.Length(),
-            filename.c_str(),
-            bytesWritten
+            filename.c_str()
         );
+        fclose(file);
         return false;
     }
 
+    fclose(file);
+
     if (Config::SavestateRelocSRAM && NDSSave)
     {
         std::string savefile = filename.substr(LastSep(filename)+1);

From 68c89dee3e10fa4ee2859048081d7538dd627725 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Thu, 27 Apr 2023 15:30:11 -0400
Subject: [PATCH 15/22] Quote the savestate's file path for clarity

---
 src/frontend/qt_sdl/ROMManager.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/frontend/qt_sdl/ROMManager.cpp b/src/frontend/qt_sdl/ROMManager.cpp
index 189ce77a8..fab542a0d 100644
--- a/src/frontend/qt_sdl/ROMManager.cpp
+++ b/src/frontend/qt_sdl/ROMManager.cpp
@@ -295,7 +295,7 @@ bool LoadState(std::string filename)
     FILE* file = fopen(filename.c_str(), "rb");
     if (file == nullptr)
     { // If we couldn't open the state file...
-        Platform::Log(Platform::LogLevel::Error, "Failed to open state file %s\n", filename.c_str());
+        Platform::Log(Platform::LogLevel::Error, "Failed to open state file \"%s\"\n", filename.c_str());
         return false;
     }
 
@@ -309,7 +309,7 @@ bool LoadState(std::string filename)
 
     if (!NDS::DoSavestate(backup.get()) || backup->Error)
     { // Back up the emulator's state. If that failed...
-        Platform::Log(Platform::LogLevel::Error, "Failed to back up state, aborting load (from %s)\n", filename.c_str());
+        Platform::Log(Platform::LogLevel::Error, "Failed to back up state, aborting load (from \"%s\")\n", filename.c_str());
         fclose(file);
         return false;
     }
@@ -319,7 +319,7 @@ bool LoadState(std::string filename)
     // Get the size of the file that we opened
     if (fseek(file, 0, SEEK_END) != 0)
     {
-        Platform::Log(Platform::LogLevel::Error, "Failed to seek to end of state file %s\n", filename.c_str());
+        Platform::Log(Platform::LogLevel::Error, "Failed to seek to end of state file \"%s\"\n", filename.c_str());
         fclose(file);
         return false;
     }
@@ -330,7 +330,7 @@ bool LoadState(std::string filename)
     std::vector<u8> buffer(size);
     if (fread(buffer.data(), size, 1, file) == 0)
     { // Read the state file into the buffer. If that failed...
-        Platform::Log(Platform::LogLevel::Error, "Failed to read %u-byte state file %s\n", size, filename.c_str());
+        Platform::Log(Platform::LogLevel::Error, "Failed to read %u-byte state file \"%s\"\n", size, filename.c_str());
         fclose(file);
         return false;
     }
@@ -341,7 +341,7 @@ bool LoadState(std::string filename)
 
     if (!NDS::DoSavestate(state.get()) || state->Error)
     { // If we couldn't load the savestate from the buffer...
-        Platform::Log(Platform::LogLevel::Error, "Failed to load state file %s into emulator\n", filename.c_str());
+        Platform::Log(Platform::LogLevel::Error, "Failed to load state file \"%s\" into emulator\n", filename.c_str());
         return false;
     }

From a64d0913b19fa3755a9690cf18e76ba04fc97442 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Thu, 27 Apr 2023 15:31:54 -0400
Subject: [PATCH 16/22] Write the savestate's length into the header

---
 src/Savestate.cpp | 15 ++++++++++++++-
 src/Savestate.h   |  1 +
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/Savestate.cpp b/src/Savestate.cpp
index 98aa2888d..e7e7a9540 100644
--- a/src/Savestate.cpp
+++ b/src/Savestate.cpp
@@ -140,7 +140,7 @@ Savestate::~Savestate()
 {
     if (Saving && !finished && !buffer_owned && !Error)
     { // If we haven't finished saving, and there hasn't been an error...
-        CloseCurrentSection();
+        Finish();
         // No need to close the active section for an owned buffer,
         // it's about to be thrown out.
     }
@@ -268,7 +268,9 @@ void Savestate::VarArray(void* data, u32 len)
 
 void Savestate::Finish()
 {
+    if (Error || finished) return;
     CloseCurrentSection();
+    WriteStateLength();
     finished = true;
 }
 
@@ -344,3 +346,14 @@ void Savestate::WriteSavestateHeader()
     // The following 4 bytes are reserved
     Var32(&zero);
 }
+
+void Savestate::WriteStateLength()
+{
+    // Not to be confused with the buffer length.
+    // The buffer might not be full,
+    // so we don't want to write out the extra stuff.
+    u32 state_length = buffer_offset;
+
+    // Write the length in the header
+    memcpy(buffer + 0x08, &state_length, sizeof(state_length));
+}
\ No newline at end of file
diff --git a/src/Savestate.h b/src/Savestate.h
index 184f6b539..a434680e8 100644
--- a/src/Savestate.h
+++ b/src/Savestate.h
@@ -109,6 +109,7 @@ class Savestate
     void CloseCurrentSection();
     bool Resize(u32 new_length);
     void WriteSavestateHeader();
+    void WriteStateLength();
     u8* buffer;
     u32 buffer_offset;
     u32 buffer_length;

From f7e2ef943abce90b5dceff57d8c43c84996c512d Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Sun, 30 Apr 2023 17:51:25 -0400
Subject: [PATCH 17/22] Add some extra logging calls

---
 src/NDS.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/NDS.cpp b/src/NDS.cpp
index 3548edbea..1f10beb35 100644
--- a/src/NDS.cpp
+++ b/src/NDS.cpp
@@ -815,7 +815,10 @@ bool DoSavestate(Savestate* file)
         u32 console;
         file->Var32(&console);
         if (console != ConsoleType)
+        {
+            Log(LogLevel::Error, "savestate: Expected console type %d, got console type %d. cannot load.\n", ConsoleType, console);
             return false;
+        }
     }
 
     file->VarArray(MainRAM, MainRAMMaxSize);
@@ -870,7 +873,11 @@ bool DoSavestate(Savestate* file)
 
     file->VarArray(DMA9Fill, 4*sizeof(u32));
 
-    if (!DoSavestate_Scheduler(file)) return false;
+    if (!DoSavestate_Scheduler(file))
+    {
+        Platform::Log(Platform::LogLevel::Error, "savestate: failed to %s scheduler state\n", file->Saving ? "save" : "load");
+        return false;
+    }
     file->Var32(&SchedListMask);
     file->Var64(&ARM9Timestamp);
     file->Var64(&ARM9Target);

From d377692824c3cd6065551bac77e9c29443ed19d0 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Sun, 30 Apr 2023 17:55:20 -0400
Subject: [PATCH 18/22] Fix section-loading

---
 src/Savestate.cpp | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/Savestate.cpp b/src/Savestate.cpp
index e7e7a9540..551d07ff9 100644
--- a/src/Savestate.cpp
+++ b/src/Savestate.cpp
@@ -176,8 +176,8 @@ void Savestate::Section(const char* magic)
     else
     {
         // Start looking at the savestate's beginning, right after its header
-
-        for (u32 offset = 0x10;;)
+        u32 offset = 0x10;
+        for (offset = 0x10;;)
         { // Until we've found the desired section...
             // Get this section's magic number
             u32 read_magic = 0;
@@ -195,15 +195,20 @@ void Savestate::Section(const char* magic)
                 // ...otherwise, let's keep looking
                 u32 read_length = 0;
                 memcpy(&read_length, buffer + offset, sizeof(read_length));
+                offset += sizeof(read_length);
 
                 // Skip past the remainder of this section
-                offset += sizeof(read_length) + read_length - sizeof(read_length);
+                // (read_length includes the size of the header;
+                // we already processed the magic and the size, so we don't need to skip them)
+                offset += read_length - sizeof(read_magic) + sizeof(read_length);
                 continue;
             }
 
             offset += 12; // Skip the extra 12 bytes we don't need
             break;
         }
+
+        buffer_offset = offset;
     }
 }

From dce7a7c013459e7c6cda37612add8ffa6008a4a9 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Sun, 30 Apr 2023 18:04:39 -0400
Subject: [PATCH 19/22] Remove the deprecated Savestate constructor

---
 src/Savestate.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Savestate.h b/src/Savestate.h
index a434680e8..db0274ed2 100644
--- a/src/Savestate.h
+++ b/src/Savestate.h
@@ -30,7 +30,6 @@ class Savestate
 {
 public:
     static constexpr u32 DEFAULT_SIZE = 32 * 1024 * 1024; // 32 MB
-    [[deprecated]] Savestate(std::string filename, bool save);
     Savestate(void* buffer, u32 size, bool save);
     explicit Savestate(u32 initial_size = DEFAULT_SIZE);

From 12ce4d5a8a937f4eba8b22df29c9f07ab48d885a Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Sun, 28 May 2023 16:02:17 -0400
Subject: [PATCH 20/22] Convert a char* to a u32 with memcpy, not a cast

---
 src/Savestate.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/Savestate.cpp b/src/Savestate.cpp
index 551d07ff9..225b53629 100644
--- a/src/Savestate.cpp
+++ b/src/Savestate.cpp
@@ -181,10 +181,13 @@ void Savestate::Section(const char* magic)
         { // Until we've found the desired section...
             // Get this section's magic number
             u32 read_magic = 0;
+            u32 magic_as_int = 0;
             memcpy(&read_magic, buffer + offset, sizeof(read_magic));
             offset += sizeof(read_magic);
 
-            if (read_magic != ((u32*)magic)[0])
+            memcpy(&magic_as_int, magic, sizeof(magic_as_int));
+
+            if (read_magic != magic_as_int)
             { // If this isn't the right section...
                 if (offset >= buffer_length)
                 { // If we've reached the end of the file without finding this section...

From 454d3ac70dcef9c499aa5748bfbebd37a7a22d19 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Mon, 29 May 2023 16:22:53 -0400
Subject: [PATCH 21/22] Fix section-handling in loads

---
 src/Savestate.cpp | 84 +++++++++++++++++++++++++++--------------------
 src/Savestate.h   |  1 +
 2 files changed, 50 insertions(+), 35 deletions(-)

diff --git a/src/Savestate.cpp b/src/Savestate.cpp
index 225b53629..546c16e03 100644
--- a/src/Savestate.cpp
+++ b/src/Savestate.cpp
@@ -175,43 +175,17 @@ void Savestate::Section(const char* magic)
     }
     else
     {
-        // Start looking at the savestate's beginning, right after its header
-        u32 offset = 0x10;
-        for (offset = 0x10;;)
-        { // Until we've found the desired section...
-            // Get this section's magic number
-            u32 read_magic = 0;
-            u32 magic_as_int = 0;
-            memcpy(&read_magic, buffer + offset, sizeof(read_magic));
-            offset += sizeof(read_magic);
-
-            memcpy(&magic_as_int, magic, sizeof(magic_as_int));
-
-            if (read_magic != magic_as_int)
-            { // If this isn't the right section...
-                if (offset >= buffer_length)
-                { // If we've reached the end of the file without finding this section...
-                    Log(LogLevel::Error, "savestate: section %s not found. blarg\n", magic);
-                    return;
-                }
-
-                // ...otherwise, let's keep looking
-                u32 read_length = 0;
-                memcpy(&read_length, buffer + offset, sizeof(read_length));
-                offset += sizeof(read_length);
-
-                // Skip past the remainder of this section
-                // (read_length includes the size of the header;
-                // we already processed the magic and the size, so we don't need to skip them)
-                offset += read_length - sizeof(read_magic) + sizeof(read_length);
-                continue;
-            }
+        u32 section_offset = FindSection(magic);
 
-            offset += 12; // Skip the extra 12 bytes we don't need
-            break;
+        if (section_offset != NO_SECTION)
+        {
+            buffer_offset = section_offset;
+        }
+        else
+        {
+            Log(LogLevel::Error, "savestate: section %s not found. blarg\n", magic);
+            Error = true;
         }
-
-        buffer_offset = offset;
     }
 }
 
@@ -364,4 +338,44 @@ void Savestate::WriteStateLength()
 
     // Write the length in the header
     memcpy(buffer + 0x08, &state_length, sizeof(state_length));
+}
+
+u32 Savestate::FindSection(const char* magic) const
+{
+    if (!magic) return NO_SECTION;
+
+    // Start looking at the savestate's beginning, right after its global header
+    // (we can't start from the current offset because then we'd lose the ability to rearrange sections)
+
+    for (u32 offset = 0x10; offset < buffer_length;)
+    { // Until we've found the desired section...
+
+        // Get this section's magic number
+        char read_magic[4] = {0};
+        memcpy(read_magic, buffer + offset, sizeof(read_magic));
+
+        if (memcmp(read_magic, magic, sizeof(read_magic)) == 0)
+        { // If this is the right section...
+            return offset + 16; // ...return the offset of the first byte of the section after the header
+        }
+
+        // Haven't found our section yet. Let's move on to the next one.
+
+        u32 section_length_offset = offset + sizeof(read_magic);
+        if (section_length_offset >= buffer_length)
+        { // If trying to read the section length would take us past the file's end...
+            break;
+        }
+
+        // First we need to find out how big this section is...
+        u32 section_length = 0;
+        memcpy(&section_length, buffer + section_length_offset, sizeof(section_length));
+
+        // ...then skip it. (The section length includes the 16-byte header.)
+        offset += section_length;
+    }
+
+    // We've reached the end of the file without finding the requested section...
+    Log(LogLevel::Error, "savestate: section %s not found. blarg\n", magic);
+    return NO_SECTION;
 }
\ No newline at end of file
diff --git a/src/Savestate.h b/src/Savestate.h
index db0274ed2..9b42af5e1 100644
--- a/src/Savestate.h
+++ b/src/Savestate.h
@@ -109,6 +109,7 @@ class Savestate
     bool Resize(u32 new_length);
     void WriteSavestateHeader();
     void WriteStateLength();
+    u32 FindSection(const char* magic) const;
     u8* buffer;
     u32 buffer_offset;
     u32 buffer_length;

From 46ee85de9a36d114b3feda1345d61fdd80935097 Mon Sep 17 00:00:00 2001
From: Jesse Talavera-Greenberg <jesse@jesse.tg>
Date: Mon, 29 May 2023 17:04:17 -0400
Subject: [PATCH 22/22] Include <cstring> in Savestate.h

- This was causing a build error on Linux
---
 src/Savestate.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Savestate.h b/src/Savestate.h
index 9b42af5e1..0aef517e4 100644
--- a/src/Savestate.h
+++ b/src/Savestate.h
@@ -19,6 +19,7 @@
 #ifndef SAVESTATE_H
 #define SAVESTATE_H
 
+#include <cstring>
 #include <string>
 #include <stdio.h>
 #include "types.h"

Places

File melonds_PR1693.patch of Package melonds (Revision d932b5faffaf790a907788760da81c73)

Places