Diamond75/Panda3DS
1
0
Fork 0
mirror of https://github.com/wheremyfoodat/Panda3DS.git synced 2025-07-08 00:02:58 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

Long overdue clang-format pass on most of the project (#773)
Some checks are pending
Android Build / x64 (release) (push) Waiting to run
Details
Android Build / arm64 (release) (push) Waiting to run
Details
HTTP Server Build / build (push) Waiting to run
Details
Hydra Core Build / Windows (push) Waiting to run
Details
Hydra Core Build / MacOS (push) Waiting to run
Details
Hydra Core Build / Linux (push) Waiting to run
Details
Hydra Core Build / Android-x64 (push) Waiting to run
Details
Hydra Core Build / ARM-Libretro (push) Waiting to run
Details
Linux AppImage Build / build (push) Waiting to run
Details
Linux Build / build (push) Waiting to run
Details
MacOS Build / MacOS-arm64 (push) Waiting to run
Details
MacOS Build / MacOS-x86_64 (push) Waiting to run
Details
MacOS Build / MacOS-Universal (push) Blocked by required conditions
Details
Qt Build / Windows (push) Waiting to run
Details
Qt Build / MacOS-arm64 (push) Waiting to run
Details
Qt Build / MacOS-x86_64 (push) Waiting to run
Details
Qt Build / MacOS-Universal (push) Blocked by required conditions
Details
Qt Build / Linux (push) Waiting to run
Details
Windows Build / build (push) Waiting to run
Details
iOS Simulator Build / build (push) Waiting to run
Details

Browse source
This commit is contained in:
wheremyfoodat 2025-07-06 18:25:20 +03:00 • committed by GitHub
parent d1f4ae2911
commit 8e20bd6220
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
65 changed files with 13445 additions and 26224 deletions
Download patch file Download diff file Expand all files Collapse all files

8
include/fs/archive_ext_save_data.hpp
View file

@ -3,10 +3,12 @@
class ExtSaveDataArchive : public ArchiveBase { class ExtSaveDataArchive : public ArchiveBase {
public: public:
ExtSaveDataArchive(Memory& mem, const std::string& folder, bool isShared = false) : ArchiveBase(mem), ExtSaveDataArchive(Memory& mem, const std::string& folder, bool isShared = false) : ArchiveBase(mem), isShared(isShared), backingFolder(folder) {}
isShared(isShared), backingFolder(folder) {}
u64 getFreeBytes() override { Helpers::panic("ExtSaveData::GetFreeBytes unimplemented"); return 0; } u64 getFreeBytes() override {
Helpers::panic("ExtSaveData::GetFreeBytes unimplemented");
return 0;
}
std::string name() override { return "ExtSaveData::" + backingFolder; } std::string name() override { return "ExtSaveData::" + backingFolder; }
HorizonResult createDirectory(const FSPath& path) override; HorizonResult createDirectory(const FSPath& path) override;

5
include/fs/archive_ncch.hpp
View file

@ -5,7 +5,10 @@ class NCCHArchive : public ArchiveBase {
public: public:
NCCHArchive(Memory& mem) : ArchiveBase(mem) {} NCCHArchive(Memory& mem) : ArchiveBase(mem) {}
u64 getFreeBytes() override { Helpers::panic("NCCH::GetFreeBytes unimplemented"); return 0; } u64 getFreeBytes() override {
Helpers::panic("NCCH::GetFreeBytes unimplemented");
return 0;
}
std::string name() override { return "NCCH"; } std::string name() override { return "NCCH"; }
HorizonResult createFile(const FSPath& path, u64 size) override; HorizonResult createFile(const FSPath& path, u64 size) override;

1
include/fs/archive_user_save_data.hpp
View file

@ -3,6 +3,7 @@
class UserSaveDataArchive : public ArchiveBase { class UserSaveDataArchive : public ArchiveBase {
u32 archiveID; u32 archiveID;
public: public:
UserSaveDataArchive(Memory& mem, u32 archiveID) : ArchiveBase(mem), archiveID(archiveID) {} UserSaveDataArchive(Memory& mem, u32 archiveID) : ArchiveBase(mem), archiveID(archiveID) {}

191
include/fs/bad_word_list.hpp
View file

@ -1,132 +1,69 @@
// Generated with https://github.com/B3n30/citra_system_archives // Generated with https://github.com/B3n30/citra_system_archives
#pragma once #pragma once
const unsigned char BAD_WORD_LIST_DATA[] = { constexpr unsigned char BAD_WORD_LIST_DATA[] = {
0x28, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00,
0x34, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x24, 0x03, 0x00, 0x00, 0xc0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0x4c, 0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x24, 0x03, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0xc0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xec, 0x02, 0x00, 0x00, 0x10, 0x02, 0x00, 0x00, 0xc0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x02, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x8c, 0x01, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xe4, 0x01, 0x00, 0x00, 0x94, 0x02, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3c, 0x02, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0xec, 0x02, 0x00, 0x00, 0x10, 0x02, 0x00, 0x00, 0xb8, 0x01, 0x00, 0x00, 0x60, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xc0, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x02, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x00, 0x00, 0x30, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00,
0xff, 0xff, 0xff, 0xff, 0x8c, 0x01, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0xe4, 0x01, 0x00, 0x00, 0x94, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x00, 0x00, 0x31, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x3c, 0x02, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x2c, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x00, 0x00, 0x00, 0x31, 0x00, 0x30, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00,
0xb8, 0x01, 0x00, 0x00, 0x60, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x31, 0x00, 0x31, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x00, 0x00, 0x00,
0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x00, 0x00, 0x00,
0x0a, 0x00, 0x00, 0x00, 0x30, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x31, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00,
0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x00, 0x00, 0x00, 0x31, 0x00, 0x33, 0x00,
0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x01, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x00, 0x00, 0x00, 0x31, 0x00, 0x34, 0x00, 0x2e, 0x00, 0x74, 0x00,
0x31, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x01, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x00, 0x00, 0x00, 0x31, 0x00, 0x35, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00,
0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x0c, 0x00, 0x00, 0x00, 0x31, 0x00, 0x30, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x00, 0x00, 0x00, 0x31, 0x00, 0x36, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00,
0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb8, 0x01, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0xb0, 0x00, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe4, 0x01, 0x00, 0x00,
0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x40, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x00, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x31, 0x00, 0x31, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x33, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0x00, 0x60, 0x01, 0x00, 0x00,
0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x00, 0x00, 0x34, 0x00, 0x2e, 0x00,
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x02, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x00, 0x00, 0x35, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00,
0x31, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x02, 0x00, 0x00, 0xa0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x36, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x94, 0x02, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x0c, 0x00, 0x00, 0x00, 0x31, 0x00, 0x33, 0x00, 0xdc, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x37, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x02, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0x34, 0x01, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x38, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xec, 0x02, 0x00, 0x00,
0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x0c, 0x00, 0x00, 0x00, 0x31, 0x00, 0x34, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x39, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x20, 0x02, 0x00, 0x00,
0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x16, 0x00, 0x00, 0x00, 0x76, 0x00, 0x65, 0x00,
0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x72, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x2e, 0x00, 0x64, 0x00, 0x61, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0c, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x31, 0x00, 0x35, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00,
0x00, 0x00, 0x00, 0x00, 0x8c, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00,
0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x0c, 0x00, 0x00, 0x00, 0x31, 0x00, 0x36, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00,
0xb8, 0x01, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00,
0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x0a, 0x00, 0x00, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00,
0x40, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00,
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x00, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x33, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x10, 0x02, 0x00, 0x00, 0x60, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00,
0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00,
0xff, 0xff, 0xff, 0xff, 0x0a, 0x00, 0x00, 0x00, 0x34, 0x00, 0x2e, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x3c, 0x02, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00,
0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00,
0x0a, 0x00, 0x00, 0x00, 0x35, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0x02, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00,
0xa0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00,
0x00, 0x00, 0x00, 0x00, 0xb0, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00
0x36, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x94, 0x02, 0x00, 0x00, 0xc0, 0x01, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xdc, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x37, 0x00, 0x2e, 0x00,
0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xc0, 0x02, 0x00, 0x00, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0x0a, 0x00, 0x00, 0x00, 0x38, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00,
0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xec, 0x02, 0x00, 0x00,
0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x39, 0x00, 0x2e, 0x00, 0x74, 0x00, 0x78, 0x00, 0x74, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x20, 0x02, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x16, 0x00, 0x00, 0x00, 0x76, 0x00, 0x65, 0x00,
0x72, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x6e, 0x00, 0x2e, 0x00,
0x64, 0x00, 0x61, 0x00, 0x74, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00,
0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00,
0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00,
0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00,
0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00,
0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00,
0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00,
0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00,
0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00,
0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00,
0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00,
0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00,
0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00,
0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00,
0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00,
0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00,
0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00,
0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00,
0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00,
0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00,
0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00,
0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00,
0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00,
0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00,
0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00,
0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xfe, 0x5e, 0x00, 0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00,
0x6f, 0x00, 0x72, 0x00, 0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x5e, 0x00,
0x62, 0x00, 0x61, 0x00, 0x64, 0x00, 0x77, 0x00, 0x6f, 0x00, 0x72, 0x00,
0x64, 0x00, 0x24, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00
}; };
const unsigned int BAD_WORD_LIST_DATA_len = 1508; const unsigned int BAD_WORD_LIST_DATA_len = 1508;

27383
include/fs/country_list.hpp
View file

File diff suppressed because it is too large Load diff

9203
include/fs/mii_data.hpp
View file

File diff suppressed because it is too large Load diff

2
include/http_server.hpp
View file

@ -19,7 +19,7 @@ class Emulator;
namespace httplib { namespace httplib {
class Server; class Server;
struct Response; struct Response;
} } // namespace httplib
// Wrapper for httplib::Response that allows the HTTP server to wait for the response to be ready // Wrapper for httplib::Response that allows the HTTP server to wait for the response to be ready
struct DeferredResponseWrapper { struct DeferredResponseWrapper {

1581
include/hydra_icon.hpp
View file

File diff suppressed because it is too large Load diff

2
include/metaprogramming.hpp
View file

@ -13,4 +13,4 @@ namespace Helpers {
static constexpr void static_for(Func&& f) { static constexpr void static_for(Func&& f) {
static_for_impl<T, Begin>(std::forward<Func>(f), std::make_integer_sequence<T, End - Begin>{}); static_for_impl<T, Begin>(std::forward<Func>(f), std::make_integer_sequence<T, End - Begin>{});
} }
} } // namespace Helpers

2
include/panda_qt/screen.hpp
View file

@ -3,8 +3,8 @@
#include <functional> #include <functional>
#include <memory> #include <memory>
#include "screen_layout.hpp"
#include "gl/context.h" #include "gl/context.h"
#include "screen_layout.hpp"
#include "window_info.h" #include "window_info.h"
// OpenGL widget for drawing the 3DS screen // OpenGL widget for drawing the 3DS screen

2
include/panda_sdl/frontend_sdl.hpp
View file

@ -4,9 +4,9 @@
#include <filesystem> #include <filesystem>
#include "screen_layout.hpp"
#include "emulator.hpp" #include "emulator.hpp"
#include "input_mappings.hpp" #include "input_mappings.hpp"
#include "screen_layout.hpp"
class FrontendSDL { class FrontendSDL {
Emulator emu; Emulator emu;

1
include/renderer_gl/gl_state.hpp
View file

@ -241,7 +241,6 @@ struct GLStateManager {
void setBlendFunc(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha) { void setBlendFunc(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha) {
if (blendFuncSourceRGB != sourceRGB || blendFuncDestRGB != destRGB || blendFuncSourceAlpha != sourceAlpha || if (blendFuncSourceRGB != sourceRGB || blendFuncDestRGB != destRGB || blendFuncSourceAlpha != sourceAlpha ||
blendFuncDestAlpha != destAlpha) { blendFuncDestAlpha != destAlpha) {
blendFuncSourceRGB = sourceRGB; blendFuncSourceRGB = sourceRGB;
blendFuncDestRGB = destRGB; blendFuncDestRGB = destRGB;
blendFuncSourceAlpha = sourceAlpha; blendFuncSourceAlpha = sourceAlpha;

2
include/result/result_common.hpp
View file

@ -203,4 +203,4 @@ namespace Result {
static constexpr HorizonResult Success(0); static constexpr HorizonResult Success(0);
static constexpr HorizonResult FailurePlaceholder(UINT32_MAX); static constexpr HorizonResult FailurePlaceholder(UINT32_MAX);
}; }; // namespace Result

1
include/services/amiibo_device.hpp
View file

@ -1,5 +1,6 @@
#pragma once #pragma once
#include <array> #include <array>
#include "helpers.hpp" #include "helpers.hpp"
#include "io_file.hpp" #include "io_file.hpp"
#include "nfc_types.hpp" #include "nfc_types.hpp"

4
include/services/apt.hpp
View file

@ -1,13 +1,13 @@
#pragma once #pragma once
#include <optional> #include <optional>
#include "applets/applet_manager.hpp"
#include "helpers.hpp" #include "helpers.hpp"
#include "kernel_types.hpp" #include "kernel_types.hpp"
#include "logger.hpp" #include "logger.hpp"
#include "memory.hpp" #include "memory.hpp"
#include "result/result.hpp" #include "result/result.hpp"
#include "applets/applet_manager.hpp"
// Yay, more circular dependencies // Yay, more circular dependencies
class Kernel; class Kernel;

2
include/system_models.hpp
View file

@ -18,6 +18,6 @@ namespace SystemModel {
KTR = NewNintendo3DS, KTR = NewNintendo3DS,
FTR = Nintendo2DS, FTR = Nintendo2DS,
RED = NewNintendo3DS_XL, RED = NewNintendo3DS_XL,
JAN = NewNintendo2DS_XL JAN = NewNintendo2DS_XL,
}; };
} }

26
src/core/CPU/dynarmic_cycles.cpp
View file

@ -6,15 +6,14 @@
#include <bit> #include <bit>
#include <functional> #include <functional>
#include "cpu_dynarmic.hpp" #include "cpu_dynarmic.hpp"
#include "helpers.hpp" #include "helpers.hpp"
namespace { namespace {
template <size_t N> template <size_t N>
struct StringLiteral { struct StringLiteral {
constexpr StringLiteral(const char(&str)[N]) { constexpr StringLiteral(const char (&str)[N]) { std::copy_n(str, N, value); }
std::copy_n(str, N, value);
}
static constexpr std::size_t strlen = N - 1; static constexpr std::size_t strlen = N - 1;
static constexpr std::size_t size = N; static constexpr std::size_t size = N;
@ -41,8 +40,7 @@ namespace {
u32 res = 0; u32 res = 0;
for (u32 bb = 1; mask; bb += bb) { for (u32 bb = 1; mask; bb += bb) {
u32 neg_mask = 0 - mask; u32 neg_mask = 0 - mask;
if (val & bb) if (val & bb) res |= mask & neg_mask;
res |= mask & neg_mask;
mask &= mask - 1; mask &= mask - 1;
} }
return res; return res;
@ -82,13 +80,10 @@ namespace {
} }
return 2; return 2;
} }
u64 LoadStoreSingle_imm(auto) { u64 LoadStoreSingle_imm(auto) { return 2; }
return 2;
}
u64 LoadStoreSingle_reg(auto i) { u64 LoadStoreSingle_reg(auto i) {
// TODO: Load PC // TODO: Load PC
if (i.template Get<"u">() == 1 && i.template Get<"r">() == 0 && if (i.template Get<"u">() == 1 && i.template Get<"r">() == 0 && (i.template Get<"v">() == 0 || i.template Get<"v">() == 2)) {
(i.template Get<"v">() == 0 || i.template Get<"v">() == 2)) {
return 2; return 2;
} }
return 4; return 4;
@ -109,12 +104,13 @@ namespace {
} }
#define INST(NAME, BS, CYCLES) \ #define INST(NAME, BS, CYCLES) \
Matcher{GetMatchingBitsFromStringLiteral<BS, "01">(), \ Matcher{ \
GetMatchingBitsFromStringLiteral<BS, "1">(), \ GetMatchingBitsFromStringLiteral<BS, "01">(), GetMatchingBitsFromStringLiteral<BS, "1">(), \
std::function<u64(u32)>{[](u32 instruction) -> u64 { \ std::function<u64(u32)>{[](u32 instruction) -> u64 { \
[[maybe_unused]] MatcherArg<BS> i{instruction}; \ [[maybe_unused]] MatcherArg<BS> i{instruction}; \
return (CYCLES); \ return (CYCLES); \
}}}, }} \
},
const std::array arm_matchers{ const std::array arm_matchers{
// clang-format off // clang-format off
@ -497,9 +493,7 @@ u64 MyEnvironment::getCyclesForInstruction(bool is_thumb, u32 instruction) {
return 1; return 1;
} }
const auto matches_instruction = [instruction](const auto& matcher) { const auto matches_instruction = [instruction](const auto& matcher) { return (instruction & matcher.mask) == matcher.expect; };
return (instruction & matcher.mask) == matcher.expect;
};
auto iter = std::find_if(arm_matchers.begin(), arm_matchers.end(), matches_instruction); auto iter = std::find_if(arm_matchers.begin(), arm_matchers.end(), matches_instruction);
if (iter != arm_matchers.end()) { if (iter != arm_matchers.end()) {

1
src/core/action_replay.cpp
View file

@ -185,7 +185,6 @@ void ActionReplay::executeDType(const Cheat& cheat, u32 instruction) {
*activeOffset += 1; *activeOffset += 1;
break; break;
case 0xD9000000: *activeData = read32(cheat[pc++] + *activeOffset); break; case 0xD9000000: *activeData = read32(cheat[pc++] + *activeOffset); break;
case 0xD9000001: data1 = read32(cheat[pc++] + *activeOffset); break; case 0xD9000001: data1 = read32(cheat[pc++] + *activeOffset); break;
case 0xD9000002: data2 = read32(cheat[pc++] + *activeOffset); break; case 0xD9000002: data2 = read32(cheat[pc++] + *activeOffset); break;

1
src/core/applets/error_applet.cpp
View file

@ -1,4 +1,5 @@
#include "applets/error_applet.hpp" #include "applets/error_applet.hpp"
#include "kernel/handles.hpp" #include "kernel/handles.hpp"
using namespace Applets; using namespace Applets;

1
src/core/cheats.cpp
View file

@ -1,4 +1,5 @@
#include "cheats.hpp" #include "cheats.hpp"
#include "swap.hpp" #include "swap.hpp"
Cheats::Cheats(Memory& mem, HIDService& hid) : ar(mem, hid) { reset(); } Cheats::Cheats(Memory& mem, HIDService& hid) : ar(mem, hid) { reset(); }

16
src/core/kernel/address_arbiter.cpp
View file

@ -38,8 +38,9 @@ void Kernel::arbitrateAddress() {
const s32 value = s32(regs[3]); const s32 value = s32(regs[3]);
const s64 ns = s64(u64(regs[4]) | (u64(regs[5]) << 32)); const s64 ns = s64(u64(regs[4]) | (u64(regs[5]) << 32));
logSVC("ArbitrateAddress(Handle = %X, address = %08X, type = %s, value = %d, ns = %lld)\n", handle, address, logSVC(
arbitrationTypeToString(type), value, ns); "ArbitrateAddress(Handle = %X, address = %08X, type = %s, value = %d, ns = %lld)\n", handle, address, arbitrationTypeToString(type), value, ns
);
const auto arbiter = getObject(handle, KernelObjectType::AddressArbiter); const auto arbiter = getObject(handle, KernelObjectType::AddressArbiter);
if (arbiter == nullptr) [[unlikely]] { if (arbiter == nullptr) [[unlikely]] {
@ -79,12 +80,8 @@ void Kernel::arbitrateAddress() {
break; break;
} }
case ArbitrationType::Signal: case ArbitrationType::Signal: signalArbiter(address, value); break;
signalArbiter(address, value); default: Helpers::panic("ArbitrateAddress: Unimplemented type %s", arbitrationTypeToString(type));
break;
default:
Helpers::panic("ArbitrateAddress: Unimplemented type %s", arbitrationTypeToString(type));
} }
requireReschedule(); requireReschedule();
@ -92,7 +89,8 @@ void Kernel::arbitrateAddress() {
// Signal up to "threadCount" threads waiting on the arbiter indicated by "waitingAddress" // Signal up to "threadCount" threads waiting on the arbiter indicated by "waitingAddress"
void Kernel::signalArbiter(u32 waitingAddress, s32 threadCount) { void Kernel::signalArbiter(u32 waitingAddress, s32 threadCount) {
if (threadCount == 0) [[unlikely]] return; if (threadCount == 0) [[unlikely]]
return;
s32 count = 0; // Number of threads we've woken up s32 count = 0; // Number of threads we've woken up
// Wake threads with the highest priority threads being woken up first // Wake threads with the highest priority threads being woken up first

2
src/core/kernel/directory_operations.cpp
View file

@ -10,7 +10,7 @@
namespace DirectoryOps { namespace DirectoryOps {
enum : u32 { enum : u32 {
Read = 0x08010042, Read = 0x08010042,
Close = 0x08020000 Close = 0x08020000,
}; };
} }

12
src/core/kernel/error.cpp
View file

@ -2,7 +2,7 @@
namespace Commands { namespace Commands {
enum : u32 { enum : u32 {
Throw = 0x00010800 Throw = 0x00010800,
}; };
} }
@ -13,7 +13,7 @@ namespace FatalErrorType {
CardRemoved = 2, CardRemoved = 2,
Exception = 3, Exception = 3,
ResultFailure = 4, ResultFailure = 4,
Logged = 5 Logged = 5,
}; };
} }
@ -21,13 +21,9 @@ namespace FatalErrorType {
void Kernel::handleErrorSyncRequest(u32 messagePointer) { void Kernel::handleErrorSyncRequest(u32 messagePointer) {
u32 cmd = mem.read32(messagePointer); u32 cmd = mem.read32(messagePointer);
switch (cmd) { switch (cmd) {
case Commands::Throw: case Commands::Throw: throwError(messagePointer); break;
throwError(messagePointer);
break;
default: default: Helpers::panic("Unimplemented err:f command %08X\n", cmd); break;
Helpers::panic("Unimplemented err:f command %08X\n", cmd);
break;
} }
} }

15
src/core/kernel/events.cpp
View file

@ -1,8 +1,9 @@
#include "kernel.hpp"
#include "cpu.hpp"
#include <bit> #include <bit>
#include <utility> #include <utility>
#include "cpu.hpp"
#include "kernel.hpp"
const char* Kernel::resetTypeToString(u32 type) { const char* Kernel::resetTypeToString(u32 type) {
switch (type) { switch (type) {
case 0: return "One shot"; case 0: return "One shot";
@ -57,11 +58,11 @@ void Kernel::svcCreateEvent() {
const u32 outPointer = regs[0]; const u32 outPointer = regs[0];
const u32 resetType = regs[1]; const u32 resetType = regs[1];
if (resetType > 2) if (resetType > 2) {
Helpers::panic("Invalid reset type for event %d", resetType); Helpers::panic("Invalid reset type for event %d", resetType);
}
logSVC("CreateEvent(handle pointer = %08X, resetType = %s)\n", outPointer, resetTypeToString(resetType)); logSVC("CreateEvent(handle pointer = %08X, resetType = %s)\n", outPointer, resetTypeToString(resetType));
regs[0] = Result::Success; regs[0] = Result::Success;
regs[1] = makeEvent(static_cast<ResetType>(resetType)); regs[1] = makeEvent(static_cast<ResetType>(resetType));
} }
@ -154,8 +155,9 @@ void Kernel::waitSynchronizationN() {
logSVC("WaitSynchronizationN (handle pointer: %08X, count: %d, timeout = %lld)\n", handles, handleCount, ns); logSVC("WaitSynchronizationN (handle pointer: %08X, count: %d, timeout = %lld)\n", handles, handleCount, ns);
if (handleCount <= 0) if (handleCount <= 0) {
Helpers::panic("WaitSyncN: Invalid handle count"); Helpers::panic("WaitSyncN: Invalid handle count");
}
// Temporary hack: Until we implement service sessions properly, don't bother sleeping when WaitSyncN targets a service handle // Temporary hack: Until we implement service sessions properly, don't bother sleeping when WaitSyncN targets a service handle
// This is necessary because a lot of games use WaitSyncN with eg the CECD service // This is necessary because a lot of games use WaitSyncN with eg the CECD service
@ -190,8 +192,7 @@ void Kernel::waitSynchronizationN() {
// Panic if one of the objects is not a valid sync object // Panic if one of the objects is not a valid sync object
if (!isWaitable(object)) [[unlikely]] { if (!isWaitable(object)) [[unlikely]] {
Helpers::panic("Tried to wait on a non waitable object in WaitSyncN. Type: %s, handle: %X\n", Helpers::panic("Tried to wait on a non waitable object in WaitSyncN. Type: %s, handle: %X\n", object->getTypeName(), handle);
object->getTypeName(), handle);
} }
if (shouldWaitOnObject(object)) { if (shouldWaitOnObject(object)) {

14
src/core/kernel/file_operations.cpp
View file

@ -69,8 +69,7 @@ void Kernel::readFile(u32 messagePointer, Handle fileHandle) {
u32 size = mem.read32(messagePointer + 12); u32 size = mem.read32(messagePointer + 12);
u32 dataPointer = mem.read32(messagePointer + 20); u32 dataPointer = mem.read32(messagePointer + 20);
logFileIO("Trying to read %X bytes from file %X, starting from offset %llX into memory address %08X\n", logFileIO("Trying to read %X bytes from file %X, starting from offset %llX into memory address %08X\n", size, fileHandle, offset, dataPointer);
size, fileHandle, offset, dataPointer);
const auto p = getObject(fileHandle, KernelObjectType::File); const auto p = getObject(fileHandle, KernelObjectType::File);
if (p == nullptr) [[unlikely]] { if (p == nullptr) [[unlikely]] {
@ -94,9 +93,8 @@ void Kernel::readFile(u32 messagePointer, Handle fileHandle) {
if (!success) { if (!success) {
Helpers::panic("Kernel::ReadFile with file descriptor failed"); Helpers::panic("Kernel::ReadFile with file descriptor failed");
} } else {
else { for (usize i = 0; i < bytesRead; i++) {
for (size_t i = 0; i < bytesRead; i++) {
mem.write8(u32(dataPointer + i), data[i]); mem.write8(u32(dataPointer + i), data[i]);
} }
@ -124,8 +122,7 @@ void Kernel::writeFile(u32 messagePointer, Handle fileHandle) {
u32 writeOption = mem.read32(messagePointer + 16); u32 writeOption = mem.read32(messagePointer + 16);
u32 dataPointer = mem.read32(messagePointer + 24); u32 dataPointer = mem.read32(messagePointer + 24);
logFileIO("Trying to write %X bytes to file %X, starting from file offset %llX and memory address %08X\n", logFileIO("Trying to write %X bytes to file %X, starting from file offset %llX and memory address %08X\n", size, fileHandle, offset, dataPointer);
size, fileHandle, offset, dataPointer);
const auto p = getObject(fileHandle, KernelObjectType::File); const auto p = getObject(fileHandle, KernelObjectType::File);
if (p == nullptr) [[unlikely]] { if (p == nullptr) [[unlikely]] {
@ -137,8 +134,9 @@ void Kernel::writeFile(u32 messagePointer, Handle fileHandle) {
Helpers::panic("Tried to write closed file"); Helpers::panic("Tried to write closed file");
} }
if (!file->fd) if (!file->fd) {
Helpers::panic("[Kernel::File::WriteFile] Tried to write to file without a valid file descriptor"); Helpers::panic("[Kernel::File::WriteFile] Tried to write to file without a valid file descriptor");
}
std::unique_ptr<u8[]> data(new u8[size]); std::unique_ptr<u8[]> data(new u8[size]);
for (size_t i = 0; i < size; i++) { for (size_t i = 0; i < size; i++) {

9
src/core/kernel/kernel.cpp
View file

@ -1,7 +1,9 @@
#include <cassert>
#include "kernel.hpp" #include "kernel.hpp"
#include "kernel_types.hpp"
#include <cassert>
#include "cpu.hpp" #include "cpu.hpp"
#include "kernel_types.hpp"
Kernel::Kernel(CPU& cpu, Memory& mem, GPU& gpu, const EmulatorConfig& config, LuaManager& lua) Kernel::Kernel(CPU& cpu, Memory& mem, GPU& gpu, const EmulatorConfig& config, LuaManager& lua)
: cpu(cpu), regs(cpu.regs()), mem(mem), handleCounter(0), serviceManager(regs, mem, gpu, currentProcess, *this, config, lua) { : cpu(cpu), regs(cpu.regs()), mem(mem), handleCounter(0), serviceManager(regs, mem, gpu, currentProcess, *this, config, lua) {
@ -278,8 +280,7 @@ void Kernel::getProcessInfo() {
regs[2] = 0; regs[2] = 0;
break; break;
default: default: Helpers::panic("GetProcessInfo: unimplemented type %d", type);
Helpers::panic("GetProcessInfo: unimplemented type %d", type);
} }
regs[0] = Result::Success; regs[0] = Result::Success;

40
src/core/kernel/memory_management.cpp
View file

@ -57,33 +57,37 @@ void Kernel::controlMemory() {
bool x = perms & 0b100; bool x = perms & 0b100;
bool linear = operation & Operation::Linear; bool linear = operation & Operation::Linear;
if (x) if (x) {
Helpers::panic("ControlMemory: attempted to allocate executable memory"); Helpers::panic("ControlMemory: attempted to allocate executable memory");
}
if (!isAligned(addr0) || !isAligned(addr1) || !isAligned(size)) { if (!isAligned(addr0) || !isAligned(addr1) || !isAligned(size)) {
Helpers::panic("ControlMemory: Unaligned parameters\nAddr0: %08X\nAddr1: %08X\nSize: %08X", addr0, addr1, size); Helpers::panic("ControlMemory: Unaligned parameters\nAddr0: %08X\nAddr1: %08X\nSize: %08X", addr0, addr1, size);
} }
logSVC("ControlMemory(addr0 = %08X, addr1 = %08X, size = %08X, operation = %X (%c%c%c)%s\n", logSVC(
addr0, addr1, size, operation, r ? 'r' : '-', w ? 'w' : '-', x ? 'x' : '-', linear ? ", linear" : "" "ControlMemory(addr0 = %08X, addr1 = %08X, size = %08X, operation = %X (%c%c%c)%s\n", addr0, addr1, size, operation, r ? 'r' : '-',
w ? 'w' : '-', x ? 'x' : '-', linear ? ", linear" : ""
); );
switch (operation & 0xFF) { switch (operation & 0xFF) {
case Operation::Commit: { case Operation::Commit: {
std::optional<u32> address = mem.allocateMemory(addr0, 0, size, linear, r, w, x, true); std::optional<u32> address = mem.allocateMemory(addr0, 0, size, linear, r, w, x, true);
if (!address.has_value()) if (!address.has_value()) {
Helpers::panic("ControlMemory: Failed to allocate memory"); Helpers::panic("ControlMemory: Failed to allocate memory");
}
regs[1] = address.value(); regs[1] = address.value();
break; break;
} }
case Operation::Map: case Operation::Map: mem.mirrorMapping(addr0, addr1, size); break;
mem.mirrorMapping(addr0, addr1, size);
break;
case Operation::Protect: case Operation::Protect:
Helpers::warn("Ignoring mprotect! Hope nothing goes wrong but if the game accesses invalid memory or crashes then we prolly need to implement this\n"); Helpers::warn(
"Ignoring mprotect! Hope nothing goes wrong but if the game accesses invalid memory or crashes then we prolly need to implement "
"this\n"
);
break; break;
default: Helpers::warn("ControlMemory: unknown operation %X\n", operation); break; default: Helpers::warn("ControlMemory: unknown operation %X\n", operation); break;
@ -130,17 +134,9 @@ void Kernel::mapMemoryBlock() {
// Pass pointer to shared memory to the appropriate service // Pass pointer to shared memory to the appropriate service
switch (block) { switch (block) {
case KernelHandles::HIDSharedMemHandle: case KernelHandles::HIDSharedMemHandle: serviceManager.setHIDSharedMem(ptr); break;
serviceManager.setHIDSharedMem(ptr); case KernelHandles::GSPSharedMemHandle: serviceManager.setGSPSharedMem(ptr); break;
break; case KernelHandles::FontSharedMemHandle: mem.copySharedFont(ptr, addr); break;
case KernelHandles::GSPSharedMemHandle:
serviceManager.setGSPSharedMem(ptr);
break;
case KernelHandles::FontSharedMemHandle:
mem.copySharedFont(ptr, addr);
break;
case KernelHandles::CSNDSharedMemHandle: case KernelHandles::CSNDSharedMemHandle:
serviceManager.setCSNDSharedMem(ptr); serviceManager.setCSNDSharedMem(ptr);
@ -178,8 +174,7 @@ void Kernel::createMemoryBlock() {
case MemoryPermissions::Read: case MemoryPermissions::Read:
case MemoryPermissions::Write: case MemoryPermissions::Write:
case MemoryPermissions::ReadWrite: case MemoryPermissions::ReadWrite:
case MemoryPermissions::DontCare: case MemoryPermissions::DontCare: return true;
return true;
default: // Permissions with the executable flag enabled or invalid permissions are not allowed default: // Permissions with the executable flag enabled or invalid permissions are not allowed
return false; return false;
@ -200,8 +195,9 @@ void Kernel::createMemoryBlock() {
// TODO: The address needs to be in a specific range otherwise it throws an invalid address error // TODO: The address needs to be in a specific range otherwise it throws an invalid address error
if (addr == 0) if (addr == 0) {
Helpers::panic("CreateMemoryBlock: Tried to use addr = 0"); Helpers::panic("CreateMemoryBlock: Tried to use addr = 0");
}
// Implement "Don't care" permission as RW // Implement "Don't care" permission as RW
if (myPermission == MemoryPermissions::DontCare) myPermission = MemoryPermissions::ReadWrite; if (myPermission == MemoryPermissions::DontCare) myPermission = MemoryPermissions::ReadWrite;

3
src/core/kernel/ports.cpp
View file

@ -1,6 +1,7 @@
#include "kernel.hpp"
#include <cstring> #include <cstring>
#include "kernel.hpp"
HorizonHandle Kernel::makePort(const char* name) { HorizonHandle Kernel::makePort(const char* name) {
Handle ret = makeObject(KernelObjectType::Port); Handle ret = makeObject(KernelObjectType::Port);
portHandles.push_back(ret); // Push the port handle to our cache of port handles portHandles.push_back(ret); // Push the port handle to our cache of port handles

1
src/core/kernel/resource_limits.cpp
View file

@ -1,4 +1,5 @@
#include "resource_limits.hpp" #include "resource_limits.hpp"
#include "kernel.hpp" #include "kernel.hpp"
// Result GetResourceLimit(Handle* resourceLimit, Handle process) // Result GetResourceLimit(Handle* resourceLimit, Handle process)

45
src/core/kernel/threads.cpp
View file

@ -43,16 +43,14 @@ void Kernel::switchThread(int newThreadIndex) {
// The threads with higher priority (aka the ones with a lower priority value) should come first in the vector // The threads with higher priority (aka the ones with a lower priority value) should come first in the vector
void Kernel::sortThreads() { void Kernel::sortThreads() {
std::vector<int>& v = threadIndices; std::vector<int>& v = threadIndices;
std::sort(v.begin(), v.end(), [&](int a, int b) { std::sort(v.begin(), v.end(), [&](int a, int b) { return threads[a].priority < threads[b].priority; });
return threads[a].priority < threads[b].priority;
});
} }
bool Kernel::canThreadRun(const Thread& t) { bool Kernel::canThreadRun(const Thread& t) {
if (t.status == ThreadStatus::Ready) { if (t.status == ThreadStatus::Ready) {
return true; return true;
} else if (t.status == ThreadStatus::WaitSleep || t.status == ThreadStatus::WaitSync1 } else if (t.status == ThreadStatus::WaitSleep || t.status == ThreadStatus::WaitSync1 || t.status == ThreadStatus::WaitSyncAny ||
|| t.status == ThreadStatus::WaitSyncAny || t.status == ThreadStatus::WaitSyncAll) { t.status == ThreadStatus::WaitSyncAll) {
// TODO: Set r0 to the correct error code on timeout for WaitSync{1/Any/All} // TODO: Set r0 to the correct error code on timeout for WaitSync{1/Any/All}
return cpu.getTicks() >= t.wakeupTick; return cpu.getTicks() >= t.wakeupTick;
} }
@ -253,8 +251,7 @@ void Kernel::acquireSyncObject(KernelObject* object, const Thread& thread) {
break; break;
} }
case KernelObjectType::Thread: case KernelObjectType::Thread: break;
break;
case KernelObjectType::Timer: { case KernelObjectType::Timer: {
Timer* timer = object->getData<Timer>(); Timer* timer = object->getData<Timer>();
@ -310,9 +307,7 @@ int Kernel::wakeupOneThread(u64 waitlist, Handle handle) {
} }
break; break;
case ThreadStatus::WaitSyncAll: case ThreadStatus::WaitSyncAll: Helpers::panic("WakeupOneThread: Thread on WaitSyncAll"); break;
Helpers::panic("WakeupOneThread: Thread on WaitSyncAll");
break;
} }
return threadIndex; return threadIndex;
@ -345,9 +340,7 @@ void Kernel::wakeupAllThreads(u64 waitlist, Handle handle) {
} }
break; break;
case ThreadStatus::WaitSyncAll: case ThreadStatus::WaitSyncAll: Helpers::panic("WakeupAllThreads: Thread on WaitSyncAll"); break;
Helpers::panic("WakeupAllThreads: Thread on WaitSyncAll");
break;
} }
} }
} }
@ -409,8 +402,7 @@ void Kernel::createThread() {
u32 initialSP = regs[3] & ~7; // SP is force-aligned to 8 bytes u32 initialSP = regs[3] & ~7; // SP is force-aligned to 8 bytes
s32 id = static_cast<s32>(regs[4]); s32 id = static_cast<s32>(regs[4]);
logSVC("CreateThread(entry = %08X, stacktop = %08X, arg = %X, priority = %X, processor ID = %d)\n", entrypoint, logSVC("CreateThread(entry = %08X, stacktop = %08X, arg = %X, priority = %X, processor ID = %d)\n", entrypoint, initialSP, arg, priority, id);
initialSP, arg, priority, id);
if (priority > 0x3F) [[unlikely]] { if (priority > 0x3F) [[unlikely]] {
Helpers::panic("Created thread with bad priority value %X", priority); Helpers::panic("Created thread with bad priority value %X", priority);
@ -525,9 +517,7 @@ void Kernel::getCurrentProcessorNumber() {
// Until we properly implement per-core schedulers, return whatever processor ID passed to svcCreateThread // Until we properly implement per-core schedulers, return whatever processor ID passed to svcCreateThread
switch (id) { switch (id) {
// TODO: This is picked from exheader // TODO: This is picked from exheader
case ProcessorID::Default: case ProcessorID::Default: ret = static_cast<s32>(ProcessorID::AppCore); break;
ret = static_cast<s32>(ProcessorID::AppCore);
break;
case ProcessorID::AllCPUs: case ProcessorID::AllCPUs:
ret = static_cast<s32>(ProcessorID::AppCore); ret = static_cast<s32>(ProcessorID::AppCore);
@ -566,9 +556,10 @@ void Kernel::exitThread() {
// Remove the index of this thread from the thread indices vector // Remove the index of this thread from the thread indices vector
for (int i = 0; i < threadIndices.size(); i++) { for (int i = 0; i < threadIndices.size(); i++) {
if (threadIndices[i] == currentThreadIndex) if (threadIndices[i] == currentThreadIndex) {
threadIndices.erase(threadIndices.begin() + i); threadIndices.erase(threadIndices.begin() + i);
} }
}
Thread& t = threads[currentThreadIndex]; Thread& t = threads[currentThreadIndex];
t.status = ThreadStatus::Dead; t.status = ThreadStatus::Dead;
@ -620,11 +611,13 @@ void Kernel::svcCreateSemaphore() {
s32 maxCount = static_cast<s32>(regs[2]); s32 maxCount = static_cast<s32>(regs[2]);
logSVC("CreateSemaphore (initial count = %d, max count = %d)\n", initialCount, maxCount); logSVC("CreateSemaphore (initial count = %d, max count = %d)\n", initialCount, maxCount);
if (initialCount > maxCount) if (initialCount > maxCount) {
Helpers::panic("CreateSemaphore: Initial count higher than max count"); Helpers::panic("CreateSemaphore: Initial count higher than max count");
}
if (initialCount < 0 || maxCount < 0) if (initialCount < 0 || maxCount < 0) {
Helpers::panic("CreateSemaphore: Negative count value"); Helpers::panic("CreateSemaphore: Negative count value");
}
regs[0] = Result::Success; regs[0] = Result::Success;
regs[1] = makeSemaphore(initialCount, maxCount); regs[1] = makeSemaphore(initialCount, maxCount);
@ -642,12 +635,10 @@ void Kernel::svcReleaseSemaphore() {
return; return;
} }
if (releaseCount < 0) if (releaseCount < 0) Helpers::panic("ReleaseSemaphore: Negative count");
Helpers::panic("ReleaseSemaphore: Negative count");
Semaphore* s = object->getData<Semaphore>(); Semaphore* s = object->getData<Semaphore>();
if (s->maximumCount - s->availableCount < releaseCount) if (s->maximumCount - s->availableCount < releaseCount) Helpers::panic("ReleaseSemaphore: Release count too high");
Helpers::panic("ReleaseSemaphore: Release count too high");
// Write success and old available count to r0 and r1 respectively // Write success and old available count to r0 and r1 respectively
regs[0] = Result::Success; regs[0] = Result::Success;
@ -693,9 +684,7 @@ bool Kernel::shouldWaitOnObject(KernelObject* object) {
case KernelObjectType::Semaphore: // Wait if the semaphore count <= 0 case KernelObjectType::Semaphore: // Wait if the semaphore count <= 0
return object->getData<Semaphore>()->availableCount <= 0; return object->getData<Semaphore>()->availableCount <= 0;
default: default: Helpers::panic("Not sure whether to wait on object (type: %s)", object->getTypeName()); return true;
Helpers::panic("Not sure whether to wait on object (type: %s)", object->getTypeName());
return true;
} }
} }

4
src/core/loader/elf.cpp
View file

@ -1,7 +1,7 @@
#include "memory.hpp"
#include <cstring> #include <cstring>
#include "elfio/elfio.hpp" #include "elfio/elfio.hpp"
#include "memory.hpp"
using namespace ELFIO; using namespace ELFIO;

27
src/core/loader/lz77.cpp
View file

@ -1,6 +1,7 @@
#include "loader/lz77.hpp"
#include <algorithm> #include <algorithm>
#include <cstring> #include <cstring>
#include "loader/lz77.hpp"
// The difference in size between the compressed and decompressed file is stored // The difference in size between the compressed and decompressed file is stored
// As a footer in the compressed file. To get the decompressed size, we extract the diff // As a footer in the compressed file. To get the decompressed size, we extract the diff
@ -34,17 +35,15 @@ bool CartLZ77::decompress(std::vector<u8>& output, const std::vector<u8>& input)
u8 control = compressed[--index]; u8 control = compressed[--index];
for (uint i = 0; i < 8; i++) { for (uint i = 0; i < 8; i++) {
if (index <= stopIndex) if (index <= stopIndex) break;
break; if (index <= 0) break;
if (index <= 0) if (out <= 0) break;
break;
if (out <= 0)
break;
if (control & 0x80) { if (control & 0x80) {
// Check if compression is out of bounds // Check if compression is out of bounds
if (index < 2) if (index < 2) {
return false; return false;
}
index -= 2; index -= 2;
u32 segmentOffset = compressed[index] | (compressed[index + 1] << 8); u32 segmentOffset = compressed[index] | (compressed[index + 1] << 8);
@ -53,22 +52,20 @@ bool CartLZ77::decompress(std::vector<u8>& output, const std::vector<u8>& input)
segmentOffset += 2; segmentOffset += 2;
// Check if compression is out of bounds // Check if compression is out of bounds
if (out < segment_size) if (out < segment_size) return false;
return false;
for (uint j = 0; j < segment_size; j++) { for (uint j = 0; j < segment_size; j++) {
// Check if compression is out of bounds // Check if compression is out of bounds
if (out + segmentOffset >= sizeDecompressed) if (out + segmentOffset >= sizeDecompressed) return false;
return false;
u8 data = output[out + segmentOffset]; u8 data = output[out + segmentOffset];
output[--out] = data; output[--out] = data;
} }
} } else {
else {
// Check if compression is out of bounds // Check if compression is out of bounds
if (out < 1) if (out < 1) {
return false; return false;
}
output[--out] = compressed[--index]; output[--out] = compressed[--index];
} }
control <<= 1; control <<= 1;

2
src/core/screen_layout.cpp
View file

@ -11,8 +11,6 @@ using namespace ScreenLayout;
void ScreenLayout::calculateCoordinates( void ScreenLayout::calculateCoordinates(
WindowCoordinates& coordinates, u32 outputWindowWidth, u32 outputWindowHeight, float topScreenPercentage, Layout layout WindowCoordinates& coordinates, u32 outputWindowWidth, u32 outputWindowHeight, float topScreenPercentage, Layout layout
) { ) {
const float destAspect = float(outputWindowWidth) / float(outputWindowHeight);
if (layout == Layout::Default || layout == Layout::DefaultFlipped) { if (layout == Layout::Default || layout == Layout::DefaultFlipped) {
// Calculate available height for each screen based on split // Calculate available height for each screen based on split
int availableTopHeight = int(outputWindowHeight * topScreenPercentage + 0.5f); int availableTopHeight = int(outputWindowHeight * topScreenPercentage + 0.5f);

1
src/core/services/act.cpp
View file

@ -1,4 +1,5 @@
#include "services/act.hpp" #include "services/act.hpp"
#include "ipc.hpp" #include "ipc.hpp"
namespace ACTCommands { namespace ACTCommands {

1
src/core/services/am.cpp
View file

@ -1,4 +1,5 @@
#include "services/am.hpp" #include "services/am.hpp"
#include "ipc.hpp" #include "ipc.hpp"
namespace AMCommands { namespace AMCommands {

4
src/core/services/amiibo_device.cpp
View file

@ -6,6 +6,4 @@ void AmiiboDevice::reset() {
} }
// Load amiibo information from our raw 540 byte array // Load amiibo information from our raw 540 byte array
void AmiiboDevice::loadFromRaw() { void AmiiboDevice::loadFromRaw() {}
}

20
src/core/services/apt.cpp
View file

@ -1,10 +1,11 @@
#include "services/apt.hpp" #include "services/apt.hpp"
#include "ipc.hpp"
#include "kernel.hpp"
#include <algorithm> #include <algorithm>
#include <vector> #include <vector>
#include "ipc.hpp"
#include "kernel.hpp"
namespace APTCommands { namespace APTCommands {
enum : u32 { enum : u32 {
GetLockHandle = 0x00010040, GetLockHandle = 0x00010040,
@ -84,8 +85,7 @@ void APTService::appletUtility(u32 messagePointer) {
u32 outputSize = mem.read32(messagePointer + 12); u32 outputSize = mem.read32(messagePointer + 12);
u32 inputPointer = mem.read32(messagePointer + 20); u32 inputPointer = mem.read32(messagePointer + 20);
log("APT::AppletUtility(utility = %d, input size = %x, output size = %x, inputPointer = %08X)\n", utility, inputSize, outputSize, log("APT::AppletUtility(utility = %d, input size = %x, output size = %x, inputPointer = %08X)\n", utility, inputSize, outputSize, inputPointer);
inputPointer);
std::vector<u8> out(outputSize); std::vector<u8> out(outputSize);
const u32 outputBuffer = mem.read32(messagePointer + 0x104); const u32 outputBuffer = mem.read32(messagePointer + 0x104);
@ -113,6 +113,7 @@ void APTService::getAppletInfo(u32 messagePointer) {
mem.write8(messagePointer + 20, 1); // 1 = registered mem.write8(messagePointer + 20, 1); // 1 = registered
mem.write8(messagePointer + 24, 1); // 1 = loaded mem.write8(messagePointer + 24, 1); // 1 = loaded
// TODO: The rest of this // TODO: The rest of this
} }
@ -298,7 +299,9 @@ void APTService::receiveParameter(u32 messagePointer) {
const u32 buffer = mem.read32(messagePointer + 0x100 + 4); const u32 buffer = mem.read32(messagePointer + 0x100 + 4);
log("APT::ReceiveParameter(app ID = %X, size = %04X)\n", app, size); log("APT::ReceiveParameter(app ID = %X, size = %04X)\n", app, size);
if (size > 0x1000) Helpers::panic("APT::ReceiveParameter with size > 0x1000"); if (size > 0x1000) {
Helpers::panic("APT::ReceiveParameter with size > 0x1000");
}
auto parameter = appletManager.receiveParameter(); auto parameter = appletManager.receiveParameter();
mem.write32(messagePointer, IPC::responseHeader(0xD, 4, 4)); mem.write32(messagePointer, IPC::responseHeader(0xD, 4, 4));
@ -326,7 +329,9 @@ void APTService::glanceParameter(u32 messagePointer) {
const u32 buffer = mem.read32(messagePointer + 0x100 + 4); const u32 buffer = mem.read32(messagePointer + 0x100 + 4);
log("APT::GlanceParameter(app ID = %X, size = %04X)\n", app, size); log("APT::GlanceParameter(app ID = %X, size = %04X)\n", app, size);
if (size > 0x1000) Helpers::panic("APT::GlanceParameter with size > 0x1000"); if (size > 0x1000) {
Helpers::panic("APT::GlanceParameter with size > 0x1000");
}
auto parameter = appletManager.glanceParameter(); auto parameter = appletManager.glanceParameter();
// TODO: Properly implement this. We currently stub it similar // TODO: Properly implement this. We currently stub it similar
@ -412,8 +417,9 @@ void APTService::getWirelessRebootInfo(u32 messagePointer) {
const u32 size = mem.read32(messagePointer + 4); // Size of data to read const u32 size = mem.read32(messagePointer + 4); // Size of data to read
log("APT::GetWirelessRebootInfo (size = %X)\n", size); log("APT::GetWirelessRebootInfo (size = %X)\n", size);
if (size > 0x10) if (size > 0x10) {
Helpers::panic("APT::GetWirelessInfo with size > 0x10 bytes"); Helpers::panic("APT::GetWirelessInfo with size > 0x10 bytes");
}
mem.write32(messagePointer, IPC::responseHeader(0x45, 1, 2)); mem.write32(messagePointer, IPC::responseHeader(0x45, 1, 2));
mem.write32(messagePointer + 4, Result::Success); mem.write32(messagePointer + 4, Result::Success);

1
src/core/services/boss.cpp
View file

@ -194,6 +194,7 @@ void BOSSService::sendProperty(u32 messagePointer) {
mem.write32(messagePointer, IPC::responseHeader(0x14, 1, 2)); mem.write32(messagePointer, IPC::responseHeader(0x14, 1, 2));
mem.write32(messagePointer + 4, Result::Success); mem.write32(messagePointer + 4, Result::Success);
mem.write32(messagePointer + 8, 0); // Read size mem.write32(messagePointer + 8, 0); // Read size
// TODO: Should this do anything else? // TODO: Should this do anything else?
} }

8
src/core/services/cfg.cpp
View file

@ -1,13 +1,14 @@
#include "services/cfg.hpp" #include "services/cfg.hpp"
#include "services/dsp.hpp"
#include "system_models.hpp"
#include "ipc.hpp"
#include <array> #include <array>
#include <bit> #include <bit>
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
#include "ipc.hpp"
#include "services/dsp.hpp"
#include "system_models.hpp"
namespace CFGCommands { namespace CFGCommands {
enum : u32 { enum : u32 {
GetConfigInfoBlk2 = 0x00010082, GetConfigInfoBlk2 = 0x00010082,
@ -120,7 +121,6 @@ void CFGService::getConfigInfoBlk2(u32 messagePointer) {
u32 output = mem.read32(messagePointer + 16); // Pointer to write the output data to u32 output = mem.read32(messagePointer + 16); // Pointer to write the output data to
log("CFG::GetConfigInfoBlk2 (size = %X, block ID = %X, output pointer = %08X\n", size, blockID, output); log("CFG::GetConfigInfoBlk2 (size = %X, block ID = %X, output pointer = %08X\n", size, blockID, output);
getConfigInfo(output, blockID, size, 0x2); getConfigInfo(output, blockID, size, 0x2);
mem.write32(messagePointer, IPC::responseHeader(0x1, 1, 2)); mem.write32(messagePointer, IPC::responseHeader(0x1, 1, 2));
mem.write32(messagePointer + 4, Result::Success); mem.write32(messagePointer + 4, Result::Success);

7
src/core/services/csnd.cpp
View file

@ -36,8 +36,8 @@ void CSNDService::handleSyncRequest(u32 messagePointer) {
void CSNDService::acquireSoundChannels(u32 messagePointer) { void CSNDService::acquireSoundChannels(u32 messagePointer) {
log("CSND::AcquireSoundChannels\n"); log("CSND::AcquireSoundChannels\n");
// The CSND service talks to the DSP using the DSP FIFO to negotiate what CSND channels are allocated to the DSP, and this seems to be channels 0-7 (usually). The rest are dedicated to CSND services. // The CSND service talks to the DSP using the DSP FIFO to negotiate what CSND channels are allocated to the DSP, and this seems to be channels
// https://www.3dbrew.org/wiki/CSND_Services // 0-7 (usually). The rest are dedicated to CSND services. https://www.3dbrew.org/wiki/CSND_Services
constexpr u32 csndChannelMask = 0xFFFFFF00; constexpr u32 csndChannelMask = 0xFFFFFF00;
mem.write32(messagePointer, IPC::responseHeader(0x5, 2, 0)); mem.write32(messagePointer, IPC::responseHeader(0x5, 2, 0));
@ -52,7 +52,8 @@ void CSNDService::initialize(u32 messagePointer) {
const u32 offset2 = mem.read32(messagePointer + 16); const u32 offset2 = mem.read32(messagePointer + 16);
const u32 offset3 = mem.read32(messagePointer + 20); const u32 offset3 = mem.read32(messagePointer + 20);
log("CSND::Initialize (Block size = %08X, offset0 = %X, offset1 = %X, offset2 = %X, offset3 = %X)\n", blockSize, offset0, offset1, offset2, offset3); log("CSND::Initialize (Block size = %08X, offset0 = %X, offset1 = %X, offset2 = %X, offset3 = %X)\n", blockSize, offset0, offset1, offset2,
offset3);
// Align block size to 4KB. CSND shared memory block is currently stubbed to be 0x3000 == 12KB, so panic if this is more than requested // Align block size to 4KB. CSND shared memory block is currently stubbed to be 0x3000 == 12KB, so panic if this is more than requested
blockSize = (blockSize + 0xFFF) & ~0xFFF; blockSize = (blockSize + 0xFFF) & ~0xFFF;

3
src/core/services/dlp_srvr.cpp
View file

@ -1,9 +1,10 @@
#include "services/dlp_srvr.hpp" #include "services/dlp_srvr.hpp"
#include "ipc.hpp" #include "ipc.hpp"
namespace DlpSrvrCommands { namespace DlpSrvrCommands {
enum : u32 { enum : u32 {
IsChild = 0x000E0040 IsChild = 0x000E0040,
}; };
} }

8
src/core/services/dsp.cpp
View file

@ -36,7 +36,7 @@ namespace DSPCommands {
namespace Result { namespace Result {
enum : u32 { enum : u32 {
HeadphonesNotInserted = 0, HeadphonesNotInserted = 0,
HeadphonesInserted = 1 HeadphonesInserted = 1,
}; };
} }
@ -168,12 +168,10 @@ DSPService::DSPEvent& DSPService::getEventRef(u32 type, u32 pipe) {
case 1: return interrupt1; case 1: return interrupt1;
case 2: case 2:
if (pipe >= pipeCount) if (pipe >= pipeCount) Helpers::panic("Tried to access the event of an invalid pipe");
Helpers::panic("Tried to access the event of an invalid pipe");
return pipeEvents[pipe]; return pipeEvents[pipe];
default: default: Helpers::panic("Unknown type for DSP::getEventRef");
Helpers::panic("Unknown type for DSP::getEventRef");
} }
} }

51
src/core/services/fs.cpp
View file

@ -1,7 +1,8 @@
#include "services/fs.hpp" #include "services/fs.hpp"
#include "kernel/kernel.hpp"
#include "io_file.hpp" #include "io_file.hpp"
#include "ipc.hpp" #include "ipc.hpp"
#include "kernel/kernel.hpp"
#include "result/result.hpp" #include "result/result.hpp"
#ifdef CreateFile // windows.h defines CreateFile & DeleteFile because of course it does. #ifdef CreateFile // windows.h defines CreateFile & DeleteFile because of course it does.
@ -47,9 +48,7 @@ namespace FSCommands {
}; };
} }
void FSService::reset() { void FSService::reset() { priority = 0; }
priority = 0;
}
// Creates directories for NAND, ExtSaveData, etc if they don't already exist. Should be executed after loading a new ROM. // Creates directories for NAND, ExtSaveData, etc if they don't already exist. Should be executed after loading a new ROM.
void FSService::initializeFilesystem() { void FSService::initializeFilesystem() {
@ -61,7 +60,6 @@ void FSService::initializeFilesystem() {
const auto systemSaveDataPath = IOFile::getAppData() / ".." / "SharedFiles" / "SystemSaveData"; const auto systemSaveDataPath = IOFile::getAppData() / ".." / "SharedFiles" / "SystemSaveData";
namespace fs = std::filesystem; namespace fs = std::filesystem;
if (!fs::is_directory(nandSharedpath)) { if (!fs::is_directory(nandSharedpath)) {
fs::create_directories(nandSharedpath); fs::create_directories(nandSharedpath);
} }
@ -89,11 +87,9 @@ ArchiveBase* FSService::getArchiveFromID(u32 id, const FSPath& archivePath) {
case ArchiveID::SaveData: return &saveData; case ArchiveID::SaveData: return &saveData;
case ArchiveID::UserSaveData2: return &userSaveData2; case ArchiveID::UserSaveData2: return &userSaveData2;
case ArchiveID::ExtSaveData: case ArchiveID::ExtSaveData: return &extSaveData_sdmc;
return &extSaveData_sdmc;
case ArchiveID::SharedExtSaveData: case ArchiveID::SharedExtSaveData: return &sharedExtSaveData_nand;
return &sharedExtSaveData_nand;
case ArchiveID::SystemSaveData: return &systemSaveData; case ArchiveID::SystemSaveData: return &systemSaveData;
case ArchiveID::SDMC: return &sdmc; case ArchiveID::SDMC: return &sdmc;
@ -104,9 +100,7 @@ ArchiveBase* FSService::getArchiveFromID(u32 id, const FSPath& archivePath) {
case ArchiveID::TwlSound: return &twlSound; case ArchiveID::TwlSound: return &twlSound;
case ArchiveID::CardSPI: return &cardSpi; case ArchiveID::CardSPI: return &cardSpi;
default: default: Helpers::panic("Unknown archive. ID: %d\n", id); return nullptr;
Helpers::panic("Unknown archive. ID: %d\n", id);
return nullptr;
} }
} }
@ -152,8 +146,7 @@ Rust::Result<HorizonHandle, Result::HorizonResult> FSService::openArchiveHandle(
archiveObject.data = new ArchiveSession(res.unwrap(), path); archiveObject.data = new ArchiveSession(res.unwrap(), path);
return Ok(handle); return Ok(handle);
} } else {
else {
return Err(res.unwrapErr()); return Err(res.unwrapErr());
} }
} }
@ -162,8 +155,7 @@ FSPath FSService::readPath(u32 type, u32 pointer, u32 size) {
std::vector<u8> data; std::vector<u8> data;
data.resize(size); data.resize(size);
for (u32 i = 0; i < size; i++) for (u32 i = 0; i < size; i++) data[i] = mem.read8(pointer + i);
data[i] = mem.read8(pointer + i);
return FSPath(type, data); return FSPath(type, data);
} }
@ -475,8 +467,9 @@ void FSService::formatSaveData(u32 messagePointer) {
log("FS::FormatSaveData\n"); log("FS::FormatSaveData\n");
const u32 archiveID = mem.read32(messagePointer + 4); const u32 archiveID = mem.read32(messagePointer + 4);
if (archiveID != ArchiveID::SaveData) if (archiveID != ArchiveID::SaveData) {
Helpers::panic("FS::FormatSaveData: Archive is not SaveData"); Helpers::panic("FS::FormatSaveData: Archive is not SaveData");
}
// Read path and path info // Read path and path info
const u32 pathType = mem.read32(messagePointer + 8); const u32 pathType = mem.read32(messagePointer + 8);
@ -486,8 +479,9 @@ void FSService::formatSaveData(u32 messagePointer) {
// Size of a block. Seems to always be 0x200 // Size of a block. Seems to always be 0x200
const u32 blockSize = mem.read32(messagePointer + 16); const u32 blockSize = mem.read32(messagePointer + 16);
if (blockSize != 0x200 && blockSize != 0x1000) if (blockSize != 0x200 && blockSize != 0x1000) {
Helpers::panic("FS::FormatSaveData: Invalid SaveData block size"); Helpers::panic("FS::FormatSaveData: Invalid SaveData block size");
}
const u32 directoryNum = mem.read32(messagePointer + 20); // Max number of directories const u32 directoryNum = mem.read32(messagePointer + 20); // Max number of directories
const u32 fileNum = mem.read32(messagePointer + 24); // Max number of files const u32 fileNum = mem.read32(messagePointer + 24); // Max number of files
@ -499,11 +493,10 @@ void FSService::formatSaveData(u32 messagePointer) {
.size = blockSize * 0x200, .size = blockSize * 0x200,
.numOfDirectories = directoryNum, .numOfDirectories = directoryNum,
.numOfFiles = fileNum, .numOfFiles = fileNum,
.duplicateData = duplicateData .duplicateData = duplicateData,
}; };
saveData.format(path, info); saveData.format(path, info);
mem.write32(messagePointer, IPC::responseHeader(0x84C, 1, 0)); mem.write32(messagePointer, IPC::responseHeader(0x84C, 1, 0));
mem.write32(messagePointer + 4, Result::Success); mem.write32(messagePointer + 4, Result::Success);
} }
@ -517,8 +510,8 @@ void FSService::deleteExtSaveData(u32 messagePointer) {
log("FS::DeleteExtSaveData (media type = %d, saveID = %llx) (stubbed)\n", mediaType, saveID); log("FS::DeleteExtSaveData (media type = %d, saveID = %llx) (stubbed)\n", mediaType, saveID);
mem.write32(messagePointer, IPC::responseHeader(0x0852, 1, 0)); mem.write32(messagePointer, IPC::responseHeader(0x0852, 1, 0));
// TODO: We can't properly implement this yet until we properly support title/save IDs. We will stub this and insert a warning for now. Required for Planet Robobot // TODO: We can't properly implement this yet until we properly support title/save IDs. We will stub this and insert a warning for now. Required
// When we properly implement it, it will just be a recursive directory deletion // for Planet Robobot When we properly implement it, it will just be a recursive directory deletion
mem.write32(messagePointer + 4, Result::Success); mem.write32(messagePointer + 4, Result::Success);
} }
@ -526,7 +519,8 @@ void FSService::createExtSaveData(u32 messagePointer) {
Helpers::warn("Stubbed call to FS::CreateExtSaveData!"); Helpers::warn("Stubbed call to FS::CreateExtSaveData!");
// First 4 words of parameters are the ExtSaveData info // First 4 words of parameters are the ExtSaveData info
// https://www.3dbrew.org/wiki/Filesystem_services#ExtSaveDataInfo // https://www.3dbrew.org/wiki/Filesystem_services#ExtSaveDataInfo
// This creates the ExtSaveData with the specified saveid in the specified media type. It stores the SMDH as "icon" in the root of the created directory. // This creates the ExtSaveData with the specified saveid in the specified media type. It stores the SMDH as "icon" in the root of the created
// directory.
const u8 mediaType = mem.read8(messagePointer + 4); const u8 mediaType = mem.read8(messagePointer + 4);
const u64 saveID = mem.read64(messagePointer + 8); const u64 saveID = mem.read64(messagePointer + 8);
const u32 numOfDirectories = mem.read32(messagePointer + 20); const u32 numOfDirectories = mem.read32(messagePointer + 20);
@ -552,12 +546,7 @@ void FSService::formatThisUserSaveData(u32 messagePointer) {
const u32 fileBucketNum = mem.read32(messagePointer + 20); // Same here const u32 fileBucketNum = mem.read32(messagePointer + 20); // Same here
const bool duplicateData = mem.read8(messagePointer + 24) != 0; const bool duplicateData = mem.read8(messagePointer + 24) != 0;
ArchiveBase::FormatInfo info { ArchiveBase::FormatInfo info{.size = blockSize * 0x200, .numOfDirectories = directoryNum, .numOfFiles = fileNum, .duplicateData = duplicateData};
.size = blockSize * 0x200,
.numOfDirectories = directoryNum,
.numOfFiles = fileNum,
.duplicateData = duplicateData
};
FSPath emptyPath; FSPath emptyPath;
mem.write32(messagePointer, IPC::responseHeader(0x080F, 1, 0)); mem.write32(messagePointer, IPC::responseHeader(0x080F, 1, 0));
@ -592,9 +581,7 @@ void FSService::controlArchive(u32 messagePointer) {
mem.write32(messagePointer + 4, Result::Success); mem.write32(messagePointer + 4, Result::Success);
break; break;
default: default: Helpers::panic("Unimplemented action for ControlArchive (action = %X)\n", action); break;
Helpers::panic("Unimplemented action for ControlArchive (action = %X)\n", action);
break;
} }
} }

14
src/core/services/ldr_ro.cpp
View file

@ -1,10 +1,11 @@
#include "services/ldr_ro.hpp" #include "services/ldr_ro.hpp"
#include "ipc.hpp"
#include "kernel.hpp"
#include <cstdio> #include <cstdio>
#include <string> #include <string>
#include "ipc.hpp"
#include "kernel.hpp"
namespace LDRCommands { namespace LDRCommands {
enum : u32 { enum : u32 {
Initialize = 0x000100C2, Initialize = 0x000100C2,
@ -66,10 +67,13 @@ namespace SegmentTable {
namespace SegmentID { namespace SegmentID {
enum : u32 { enum : u32 {
TEXT, RODATA, DATA, BSS, TEXT,
RODATA,
DATA,
BSS,
}; };
} }
} } // namespace SegmentTable
namespace NamedExportTable { namespace NamedExportTable {
enum : u32 { enum : u32 {
@ -130,7 +134,7 @@ namespace RelocationPatch {
AbsoluteAddress = 2, AbsoluteAddress = 2,
}; };
}; };
}; }; // namespace RelocationPatch
struct CROHeaderEntry { struct CROHeaderEntry {
u32 offset, size; u32 offset, size;

6
src/core/services/mic.cpp
View file

@ -1,4 +1,5 @@
#include "services/mic.hpp" #include "services/mic.hpp"
#include "ipc.hpp" #include "ipc.hpp"
#include "kernel/kernel.hpp" #include "kernel/kernel.hpp"
@ -127,9 +128,8 @@ void MICService::startSampling(u32 messagePointer) {
u32 dataSize = mem.read32(messagePointer + 16); u32 dataSize = mem.read32(messagePointer + 16);
bool loop = mem.read8(messagePointer + 20); bool loop = mem.read8(messagePointer + 20);
log("MIC::StartSampling (encoding = %d, sample rate = %d, offset = %08X, size = %08X, loop: %s) (stubbed)\n", log("MIC::StartSampling (encoding = %d, sample rate = %d, offset = %08X, size = %08X, loop: %s) (stubbed)\n", encoding, sampleRate, offset,
encoding, sampleRate, offset, dataSize, loop ? "yes" : "no" dataSize, loop ? "yes" : "no");
);
currentlySampling = true; currentlySampling = true;
mem.write32(messagePointer, IPC::responseHeader(0x3, 1, 0)); mem.write32(messagePointer, IPC::responseHeader(0x3, 1, 0));

1
src/core/services/ndm.cpp
View file

@ -1,4 +1,5 @@
#include "services/ndm.hpp" #include "services/ndm.hpp"
#include "ipc.hpp" #include "ipc.hpp"
namespace NDMCommands { namespace NDMCommands {

3
src/core/services/news_u.cpp
View file

@ -1,6 +1,7 @@
#include "ipc.hpp"
#include "services/news_u.hpp" #include "services/news_u.hpp"
#include "ipc.hpp"
namespace NewsCommands { namespace NewsCommands {
enum : u32 {}; enum : u32 {};
} }

2
src/core/services/nfc.cpp
View file

@ -1,4 +1,5 @@
#include "services/nfc.hpp" #include "services/nfc.hpp"
#include "io_file.hpp" #include "io_file.hpp"
#include "ipc.hpp" #include "ipc.hpp"
#include "kernel.hpp" #include "kernel.hpp"
@ -166,7 +167,6 @@ void NFCService::communicationGetStatus(u32 messagePointer) {
mem.write8(messagePointer + 8, static_cast<u32>(adapterStatus)); mem.write8(messagePointer + 8, static_cast<u32>(adapterStatus));
} }
void NFCService::communicationGetResult(u32 messagePointer) { void NFCService::communicationGetResult(u32 messagePointer) {
log("NFC::CommunicationGetResult\n"); log("NFC::CommunicationGetResult\n");

3
src/core/services/nim.cpp
View file

@ -1,9 +1,10 @@
#include "services/nim.hpp" #include "services/nim.hpp"
#include "ipc.hpp" #include "ipc.hpp"
namespace NIMCommands { namespace NIMCommands {
enum : u32 { enum : u32 {
Initialize = 0x00210000 Initialize = 0x00210000,
}; };
} }

3
src/core/services/nwm_uds.cpp
View file

@ -1,7 +1,8 @@
#include "services/nwm_uds.hpp"
#include "ipc.hpp" #include "ipc.hpp"
#include "kernel.hpp" #include "kernel.hpp"
#include "result/result.hpp" #include "result/result.hpp"
#include "services/nwm_uds.hpp"
namespace NWMCommands { namespace NWMCommands {
enum : u32 { enum : u32 {

6
src/core/services/ssl.cpp
View file

@ -1,6 +1,7 @@
#include "services/ssl.hpp"
#include "ipc.hpp" #include "ipc.hpp"
#include "result/result.hpp" #include "result/result.hpp"
#include "services/ssl.hpp"
namespace SSLCommands { namespace SSLCommands {
enum : u32 { enum : u32 {
@ -48,7 +49,8 @@ void SSLService::generateRandomData(u32 messagePointer) {
u32 data; u32 data;
for (u32 i = 0; i < size; i++) { for (u32 i = 0; i < size; i++) {
// We don't have an available random value since we're on a multiple of 4 bytes and our Twister is 32-bit, generate a new one from the Mersenne Twister // We don't have an available random value since we're on a multiple of 4 bytes and our Twister is 32-bit, generate a new one from the
// Mersenne Twister
if ((i & 3) == 0) { if ((i & 3) == 0) {
data = rng(); data = rng();
} }