[dynarmic] Add A64:SM4/SM3 tests

Signed-off-by: lizzie <lizzie@eden-emu.dev>

src/core/file_sys/fs_path.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -146,16 +143,20 @@ public:
         return m_str;
     }
 
-    size_t GetLength() const {
-        return std::strlen(this->GetString());
+    constexpr size_t GetLength() const {
+        if (std::is_constant_evaluated()) {
+            return Strlen(this->GetString());
+        } else {
+            return std::strlen(this->GetString());
+        }
     }
 
     constexpr bool IsEmpty() const {
         return *m_str == '\x00';
     }
 
-    bool IsMatchHead(const char* p, size_t len) const {
-        return std::strncmp(this->GetString(), p, len) == 0;
+    constexpr bool IsMatchHead(const char* p, size_t len) const {
+        return Strncmp(this->GetString(), p, len) == 0;
     }
 
     Result Initialize(const Path& rhs) {
@@ -168,7 +169,7 @@ public:
         R_TRY(this->Preallocate(len + 1));
 
         // Copy the path
-        const size_t copied = strlcpy(m_write_buffer.Get(), rhs.GetString(), len + 1);
+        const size_t copied = Strlcpy<char>(m_write_buffer.Get(), rhs.GetString(), len + 1);
         R_UNLESS(copied == len, ResultUnexpectedInPathA);
 
         // Set normalized
@@ -330,14 +331,14 @@ public:
         // Get our write buffer
         auto* dst = m_write_buffer.Get();
         if (old_write_buffer.Get() != nullptr && cur_len > 0) {
-            strlcpy(dst, old_write_buffer.Get(), cur_len + 1);
+            Strlcpy<char>(dst, old_write_buffer.Get(), cur_len + 1);
         }
 
         // Add separator
         dst[cur_len] = '/';
 
         // Copy the child path
-        const size_t copied = strlcpy(dst + cur_len + 1, c, child_len + 1);
+        const size_t copied = Strlcpy<char>(dst + cur_len + 1, c, child_len + 1);
         R_UNLESS(copied == child_len, ResultUnexpectedInPathA);
 
         R_SUCCEED();
@@ -374,7 +375,7 @@ public:
         if (m_write_buffer.Get() == nullptr) {
             if (const auto len = std::strlen(m_str); len > 0) {
                 R_TRY(this->Preallocate(len));
-                strlcpy(m_write_buffer.Get(), m_str, len + 1);
+                Strlcpy<char>(m_write_buffer.Get(), m_str, len + 1);
             }
         }
 
@@ -496,7 +497,7 @@ private:
             R_TRY(this->Preallocate(size + 1));
 
             // Copy the path
-            const size_t copied = strlcpy(m_write_buffer.Get(), path, size + 1);
+            const size_t copied = Strlcpy<char>(m_write_buffer.Get(), path, size + 1);
             R_UNLESS(copied >= size, ResultUnexpectedInPathA);
         } else {
             // We can just clear the buffer

src/core/file_sys/fs_path_utility.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -1217,7 +1217,7 @@ public:
                 replaced_src = static_cast<char*>(Allocate(replaced_src_len));
             }
 
-            strlcpy(replaced_src, src, replaced_src_len);
+            Strlcpy<char>(replaced_src, src, replaced_src_len);
 
             Replace(replaced_src, replaced_src_len, AlternateDirectorySeparator,
                     DirectorySeparator);

src/core/file_sys/fs_string_util.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -10,6 +7,85 @@
 
 namespace FileSys {
 
+template <typename T>
+constexpr int Strlen(const T* str) {
+    ASSERT(str != nullptr);
+
+    int length = 0;
+    while (*str++) {
+        ++length;
+    }
+
+    return length;
+}
+
+template <typename T>
+constexpr int Strnlen(const T* str, std::size_t count) {
+    return Strnlen(str, static_cast<int>(count));
+}
+
+template <typename T>
+constexpr int Strnlen(const T* str, int count) {
+    ASSERT(str != nullptr);
+    ASSERT(count >= 0);
+
+    int length = 0;
+    while (count-- && *str++) {
+        ++length;
+    }
+
+    return length;
+}
+
+template <typename T>
+constexpr int Strncmp(const T* lhs, const T* rhs, std::size_t count) {
+    return Strncmp(lhs, rhs, static_cast<int>(count));
+}
+
+template <typename T>
+constexpr int Strncmp(const T* lhs, const T* rhs, int count) {
+    ASSERT(lhs != nullptr);
+    ASSERT(rhs != nullptr);
+    ASSERT(count >= 0);
+
+    if (count == 0) {
+        return 0;
+    }
+
+    T l, r;
+    do {
+        l = *(lhs++);
+        r = *(rhs++);
+    } while (l && (l == r) && (--count));
+
+    return l - r;
+}
+
+template <typename T>
+static constexpr int Strlcpy(T* dst, const T* src, std::size_t count) {
+    return Strlcpy<T>(dst, src, static_cast<int>(count));
+}
+
+template <typename T>
+static constexpr int Strlcpy(T* dst, const T* src, int count) {
+    ASSERT(dst != nullptr);
+    ASSERT(src != nullptr);
+
+    const T* cur = src;
+    if (count > 0) {
+        while ((--count) && *cur) {
+            *(dst++) = *(cur++);
+        }
+        *dst = 0;
+    }
+
+    while (*cur) {
+        cur++;
+    }
+
+    return static_cast<int>(cur - src);
+}
+
 enum CharacterEncodingResult {
     CharacterEncodingResult_Success = 0,
     CharacterEncodingResult_InsufficientLength = 1,

src/dynarmic/tests/A64/a64.cpp

@@ -2632,3 +2632,66 @@ TEST_CASE("A64: Rounding", "[a64]") {
     CHECK(jit.GetVector(5) == Vector{0x4000000040000000, 0x4000000040000000});
     CHECK(jit.GetVector(6) == Vector{0x4000000040000000, 0x4000000040000000});
 }
+
+TEST_CASE("A64: SM4", "[a64]") {
+    A64TestEnv env;
+    A64::UserConfig jit_user_config{};
+    jit_user_config.callbacks = &env;
+    A64::Jit jit{jit_user_config};
+
+    oaknut::VectorCodeGenerator code{env.code_mem, nullptr};
+
+    code.SM4EKEY(V4.S4(), V0.S4(), V1.S4());
+    code.SM4E(V5.S4(), V0.S4(), V1.S4());
+
+    jit.SetPC(0);
+    jit.SetVector(0, {0xefcdab8967452301, 0x1032547698badcfe});
+    jit.SetVector(1, {0xefcdab8967452301, 0x1032547698badcfe});
+    env.ticks_left = env.code_mem.size();
+    CheckedRun([&]() { jit.Run(); });
+
+    CHECK(jit.GetVector(4) == Vector{0x486a0c2e00224466, 0x5c7e183a62402604});
+    CHECK(jit.GetVector(5) == Vector{0xc2e086a43c1e785a, 0xd7f593b104264062});
+}
+
+TEST_CASE("A64: SM3", "[a64]") {
+    A64TestEnv env;
+    A64::UserConfig jit_user_config{};
+    jit_user_config.callbacks = &env;
+    SECTION("SM3SS1") {
+        A64::Jit jit{jit_user_config};
+        oaknut::VectorCodeGenerator code{env.code_mem, nullptr};
+        code.SM3SS1(V0.S4(), V0.S4(), V1.S4(), V2.S4());
+        jit.SetPC(0);
+        jit.SetVector(0, {0xec4aff517369c667, 0x46e3fbf2abbacd29});
+        jit.SetVector(1, {0x8de7e81bf854c27c, 0x9ac99f33632e5a76});
+        jit.SetVector(2, {0x5aa35831b70d3266, 0xd45ee95817055d25});
+        env.ticks_left = env.code_mem.size();
+        CheckedRun([&]() { jit.Run(); });
+        CHECK(jit.GetVector(0) == Vector{0x0000000000000000, 0x73d67cd700000000});
+    }
+    SECTION("SM3PARTW1") {
+        A64::Jit jit{jit_user_config};
+        oaknut::VectorCodeGenerator code{env.code_mem, nullptr};
+        code.SM3PARTW1(V0.S4(), V0.S4(), V1.S4(), V2.S4());
+        jit.SetPC(0);
+        jit.SetVector(0, {0xec4aff517369c667, 0x46e3fbf2abbacd29});
+        jit.SetVector(1, {0x8de7e81bf854c27c, 0x9ac99f33632e5a76});
+        jit.SetVector(2, {0x5aa35831b70d3266, 0xd45ee95817055d25});
+        env.ticks_left = env.code_mem.size();
+        CheckedRun([&]() { jit.Run(); });
+        CHECK(jit.GetVector(0) == Vector{0x653c64995693280c, 0xabcc7db97adebf12});
+    }
+    SECTION("SM3PARTW2") {
+        A64::Jit jit{jit_user_config};
+        oaknut::VectorCodeGenerator code{env.code_mem, nullptr};
+        code.SM3PARTW2(V0.S4(), V0.S4(), V1.S4(), V2.S4());
+        jit.SetPC(0);
+        jit.SetVector(0, {0xec4aff517369c667, 0x46e3fbf2abbacd29});
+        jit.SetVector(1, {0x8de7e81bf854c27c, 0x9ac99f33632e5a76});
+        jit.SetVector(2, {0x5aa35831b70d3266, 0xd45ee95817055d25});
+        env.ticks_left = env.code_mem.size();
+        CheckedRun([&]() { jit.Run(); });
+        CHECK(jit.GetVector(0) == Vector{0x30010fe70da43740, 0x6702425b4a3a05d4});
+    }
+}