Super Mario Odyssey

src/common/CMakeLists.txt

@@ -3,6 +3,7 @@ add_library(hydra-common
     macros.hpp
     type_aliases.hpp
     types.hpp
+    range.hpp
     traits.hpp
     functions.hpp
     atomic.hpp
@@ -15,6 +16,7 @@ add_library(hydra-common
     pool.hpp
     static_pool.hpp
     dynamic_pool.hpp
+    small_cache.hpp
     filesystem.hpp
     log.cpp
     log.hpp

src/common/common.hpp

@@ -25,6 +25,8 @@
 #include "common/objc.hpp"
 #include "common/optional_helper.hpp"
 #include "common/platform.hpp"
+#include "common/range.hpp"
+#include "common/small_cache.hpp"
 #include "common/static_pool.hpp"
 #include "common/string.hpp"
 #include "common/time.hpp"

src/common/config.cpp

@@ -137,6 +137,7 @@ void Config::LoadDefaults() {
     log_fs_access = GetDefaultLogFsAccess();
     debug_logging = GetDefaultDebugLogging();
     process_args = GetDefaultProcessArgs();
+    recover_from_segfault = GetDefaultRecoverFromSegfault();
     gdb_enabled = GetDefaultGdbEnabled();
     gdb_port = GetDefaultGdbPort();
     gdb_wait_for_client = GetDefaultGdbWaitForClient();
@@ -218,6 +219,7 @@ void Config::Serialize() {
         debug["log_fs_access"] = log_fs_access;
         debug["debug_logging"] = debug_logging;
         debug["process_args"] = process_args;
+        debug["recover_from_segfault"] = recover_from_segfault;
         debug["gdb_enabled"] = gdb_enabled;
         debug["gdb_port"] = gdb_port;
         debug["gdb_wait_for_client"] = gdb_wait_for_client;
@@ -303,6 +305,8 @@ void Config::Deserialize() {
                                             GetDefaultDebugLogging());
         process_args = toml::find_or<std::vector<std::string>>(
             debug, "process_args", GetDefaultProcessArgs());
+        recover_from_segfault = toml::find_or<bool>(
+            debug, "recover_from_segfault", GetDefaultRecoverFromSegfault());
         gdb_enabled =
             toml::find_or<bool>(debug, "gdb_enabled", GetDefaultGdbEnabled());
         gdb_port = toml::find_or<u16>(debug, "gdb_port", GetDefaultGdbPort());
@@ -365,6 +369,7 @@ void Config::Log() {
     LOG_INFO(Other, "Log FS access: {}", log_fs_access);
     LOG_INFO(Other, "Debug logging: {}", debug_logging);
     LOG_INFO(Other, "Process arguments: {}", process_args);
+    LOG_INFO(Other, "Recover from segfault: {}", recover_from_segfault);
     LOG_INFO(Other, "GDB enabled: {}", gdb_enabled);
     LOG_INFO(Other, "GDB port: {}", gdb_port);
     LOG_INFO(Other, "GDB wait for client: {}", gdb_wait_for_client);

src/common/config.hpp

@@ -107,6 +107,7 @@ class Config {
     bool log_fs_access;
     bool debug_logging;
     std::vector<std::string> process_args;
+    bool recover_from_segfault;
     bool gdb_enabled;
     u16 gdb_port;
     bool gdb_wait_for_client;
@@ -154,6 +155,7 @@ class Config {
     bool GetDefaultLogFsAccess() const { return false; }
     bool GetDefaultDebugLogging() const { return false; }
     std::vector<std::string> GetDefaultProcessArgs() const { return {}; }
+    bool GetDefaultRecoverFromSegfault() const { return false; }
     bool GetDefaultGdbEnabled() const { return false; }
     u16 GetDefaultGdbPort() const { return 1234; }
     bool GetDefaultGdbWaitForClient() const { return false; }
@@ -179,6 +181,7 @@ class Config {
     REF_GETTER(log_fs_access, GetLogFsAccess);
     REF_GETTER(debug_logging, GetDebugLogging);
     REF_GETTER(process_args, GetProcessArgs);
+    REF_GETTER(recover_from_segfault, GetRecoverFromSegfault);
     REF_GETTER(gdb_enabled, GetGdbEnabled);
     REF_GETTER(gdb_port, GetGdbPort);
     REF_GETTER(gdb_wait_for_client, GetGdbWaitForClient);

src/common/functions.hpp

@@ -63,7 +63,7 @@ T align(T v, T alignment) {
 
 template <typename T>
 bool is_aligned(T v, T alignment) {
-    return (v & (alignment - 1)) == 0x0;
+    return (v % alignment) == 0x0;
 }
 
 template <typename T>
@@ -136,14 +136,6 @@ inline std::string u64_to_str(u64 value) {
     return std::string(str, std::min(strlen(str), size_t(8)));
 }
 
-template <typename T>
-void push_unique(std::vector<T>& vec, T value) {
-    auto it = std::find_if(vec.begin(), vec.end(),
-                           [&](const T v) { return v == value; });
-    if (it == vec.end())
-        vec.push_back(value);
-}
-
 inline std::string demangle(const char* mangled_name) {
     i32 status;
     std::unique_ptr<char, void (*)(void*)> result{

src/common/io/sparse_stream.hpp

@@ -1,11 +1,12 @@
 #pragma once
 
 #include "common/io/stream.hpp"
+#include "common/range.hpp"
 
 namespace hydra::io {
 
 struct SparseStreamEntry {
-    range<u64> range;
+    Range<u64> range;
     IStream* stream;
 };
 
@@ -38,9 +39,9 @@ class SparseStream : public IStream {
 
             const auto entry = GetEntry(seek);
             const auto max_read_size = std::min(
-                entry.range.end - seek, static_cast<u64>(buffer.size()));
+                entry.range.GetEnd() - seek, static_cast<u64>(buffer.size()));
             if (entry.stream) {
-                entry.stream->SeekTo(seek - entry.range.begin);
+                entry.stream->SeekTo(seek - entry.range.GetBegin());
                 entry.stream->ReadRaw(buffer.subspan(0, max_read_size));
             } else {
                 std::fill(buffer.begin(),
@@ -59,9 +60,9 @@ class SparseStream : public IStream {
 
             const auto entry = GetEntry(seek);
             const auto max_write_size = std::min(
-                entry.range.end - seek, static_cast<u64>(buffer.size()));
+                entry.range.GetEnd() - seek, static_cast<u64>(buffer.size()));
             if (entry.stream) {
-                entry.stream->SeekTo(seek - entry.range.begin);
+                entry.stream->SeekTo(seek - entry.range.GetBegin());
                 entry.stream->WriteRaw(buffer.subspan(0, max_write_size));
             }
 
@@ -92,23 +93,23 @@ class SparseStream : public IStream {
         auto next_it =
             std::upper_bound(entries.begin(), entries.end(), offset,
                              [](u64 offset, const SparseStreamEntry& entry) {
-                                 return offset < entry.range.begin;
+                                 return offset < entry.range.GetBegin();
                              });
 
         // If the offset is before the first entry, return an empty entry
         if (next_it == entries.begin())
-            return {.stream = nullptr, .range = {0, next_it->range.begin}};
+            return {.stream = nullptr, .range = {0, next_it->range.GetBegin()}};
 
         auto it = std::prev(next_it);
 
         // Check if entry is past the range
         if (!it->range.Contains(offset)) {
             if (next_it == entries.end())
                 return {.stream = nullptr,
-                        .range = {it->range.end, size - offset}};
+                        .range = {it->range.GetEnd(), size - offset}};
 
             return {.stream = nullptr,
-                    .range = {it->range.end, next_it->range.begin}};
+                    .range = {it->range.GetEnd(), next_it->range.GetBegin()}};
         }
 
         // Cache the entry and return it

src/common/log.hpp

@@ -65,7 +65,8 @@
 
 #define ASSERT_ALIGNMENT(value, alignment, c, name)                            \
     ASSERT(is_aligned<decltype(value)>(value, alignment), c,                   \
-           name " must be {}-byte aligned", alignment)
+           name " must be {:#x}-byte aligned (value: {:#x})", alignment,       \
+           value)
 
 #ifdef HYDRA_DEBUG
 #define ASSERT_DEBUG(condition, c, ...) ASSERT(condition, c, __VA_ARGS__)

src/common/macros.hpp

@@ -104,6 +104,8 @@
     decltype(member)& name() { return member; }
 #define CONST_REF_GETTER(member, name)                                         \
     const decltype(member)& name() const { return member; }
+#define CONSTEXPR_GETTER(member, name)                                         \
+    constexpr decltype(member) name() const { return member; }
 
 #define SETTER(member, name)                                                   \
     void name(const decltype(member) member##_) { member = member##_; }
@@ -131,6 +133,9 @@
                                               setter_name)                     \
     CONST_REF_GETTER(member, getter_name)                                      \
     CONST_REF_SETTER(member, setter_name)
+#define CONSTEXPR_GETTER_AND_SETTER(member, getter_name, setter_name)          \
+    CONSTEXPR_GETTER(member, getter_name)                                      \
+    SETTER(member, setter_name)
 
 #define PARENS ()
 

src/common/range.hpp

@@ -0,0 +1,89 @@
+#pragma once
+
+#include "common/functions.hpp"
+#include "common/log.hpp"
+#include "common/macros.hpp"
+#include "common/type_aliases.hpp"
+
+namespace hydra {
+
+template <typename T>
+class Range {
+  public:
+    static constexpr Range<T> FromSize(T begin_, T size) {
+        return Range<T>(begin_, begin_ + size);
+    }
+
+    constexpr Range() : begin{0}, end{0} {}
+    constexpr Range(T begin_, T end_) : begin{begin_}, end{end_} {}
+
+    bool operator==(const Range<T>& other) const {
+        return begin == other.begin && end == other.end;
+    }
+
+    void operator+=(T offset) {
+        begin += offset;
+        end += offset;
+    }
+
+    void operator-=(T offset) {
+        begin -= offset;
+        end -= offset;
+    }
+
+    // Size
+    constexpr T GetSize() const { return end - begin; }
+    constexpr void SetSize(T size) { end = begin + size; }
+
+    // Intersection
+    bool Contains(T value) const { return value >= begin && value < end; }
+    bool Contains(const Range<T>& other) const {
+        return other.begin >= begin && other.end <= end;
+    }
+
+    bool Intersects(const Range<T>& other) const {
+        return begin < other.end && end > other.begin;
+    }
+
+    // Combining
+    Range<T> ClampedTo(const Range<T>& bounds) const {
+        return Range<T>(std::max(begin, bounds.begin),
+                        std::min(end, bounds.end));
+    }
+
+    Range<T> Union(const Range<T>& other) const {
+        return Range<T>(std::min(begin, other.begin), std::max(end, other.end));
+    }
+
+  private:
+    T begin;
+    T end;
+
+  public:
+    CONSTEXPR_GETTER_AND_SETTER(begin, GetBegin, SetBegin);
+    CONSTEXPR_GETTER_AND_SETTER(end, GetEnd, SetEnd);
+};
+
+} // namespace hydra
+
+template <typename T>
+struct fmt::formatter<hydra::Range<T>> : formatter<string_view> {
+    fmt::formatter<T> value_formatter;
+
+    constexpr auto parse(fmt::format_parse_context& ctx) {
+        return value_formatter.parse(ctx);
+    }
+
+    template <typename FormatContext>
+    auto format(const hydra::Range<T>& range, FormatContext& ctx) const {
+        auto out = ctx.out();
+
+        *out++ = '<';
+        out = value_formatter.format(range.GetBegin(), ctx);
+        out = fmt::format_to(out, "...");
+        out = value_formatter.format(range.GetEnd(), ctx);
+        *out++ = ')';
+
+        return out;
+    }
+};