diff options
| -rw-r--r-- | src/core/file_sys/archive_savedata.cpp | 9 | ||||
| -rw-r--r-- | src/core/hle/kernel/process.cpp | 9 | ||||
| -rw-r--r-- | src/core/hle/kernel/process.h | 9 | ||||
| -rw-r--r-- | src/core/loader/3dsx.cpp | 5 | ||||
| -rw-r--r-- | src/core/loader/elf.cpp | 5 | ||||
| -rw-r--r-- | src/core/loader/ncch.cpp | 5 | ||||
| -rw-r--r-- | src/core/loader/nso.cpp | 223 | ||||
| -rw-r--r-- | src/core/loader/nso.h | 25 | ||||
| -rw-r--r-- | src/tests/core/hle/kernel/hle_ipc.cpp | 4 |
9 files changed, 162 insertions, 132 deletions
diff --git a/src/core/file_sys/archive_savedata.cpp b/src/core/file_sys/archive_savedata.cpp index 61f7654f7..67076c73f 100644 --- a/src/core/file_sys/archive_savedata.cpp +++ b/src/core/file_sys/archive_savedata.cpp @@ -15,16 +15,19 @@ ArchiveFactory_SaveData::ArchiveFactory_SaveData( : sd_savedata_source(sd_savedata) {} ResultVal<std::unique_ptr<ArchiveBackend>> ArchiveFactory_SaveData::Open(const Path& path) { - return sd_savedata_source->Open(Kernel::g_current_process->codeset->program_id); + UNIMPLEMENTED(); + return {}; //sd_savedata_source->Open(Kernel::g_current_process->codeset->program_id); } ResultCode ArchiveFactory_SaveData::Format(const Path& path, const FileSys::ArchiveFormatInfo& format_info) { - return sd_savedata_source->Format(Kernel::g_current_process->codeset->program_id, format_info); + UNIMPLEMENTED(); + return RESULT_SUCCESS; //sd_savedata_source->Format(Kernel::g_current_process->codeset->program_id, format_info); } ResultVal<ArchiveFormatInfo> ArchiveFactory_SaveData::GetFormatInfo(const Path& path) const { - return sd_savedata_source->GetFormatInfo(Kernel::g_current_process->codeset->program_id); + UNIMPLEMENTED(); + return {}; //sd_savedata_source->GetFormatInfo(Kernel::g_current_process->codeset->program_id); } } // namespace FileSys diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp index 2b6634069..2a80c2492 100644 --- a/src/core/hle/kernel/process.cpp +++ b/src/core/hle/kernel/process.cpp @@ -30,10 +30,10 @@ CodeSet::~CodeSet() {} u32 Process::next_process_id; -SharedPtr<Process> Process::Create(SharedPtr<CodeSet> code_set) { +SharedPtr<Process> Process::Create(std::string&& name) { SharedPtr<Process> process(new Process); - process->codeset = code_set; + process->name = std::move(name); process->flags.raw = 0; process->flags.memory_region.Assign(MemoryRegion::APPLICATION); @@ -112,7 +112,7 @@ void Process::ParseKernelCaps(const u32* kernel_caps, size_t len) { } } -void Process::Run(s32 main_thread_priority, u32 stack_size) { +void Process::Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size) { // Allocate and map stack vm_manager .MapMemoryBlock(Memory::HEAP_VADDR_END - stack_size, @@ -129,7 +129,8 @@ void Process::Run(s32 main_thread_priority, u32 stack_size) { } vm_manager.LogLayout(Log::Level::Debug); - Kernel::SetupMainThread(codeset->entrypoint, main_thread_priority); + Kernel::SetupMainThread(entry_point, main_thread_priority); +} void Process::LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr) { memory_region = GetMemoryRegion(flags.memory_region); diff --git a/src/core/hle/kernel/process.h b/src/core/hle/kernel/process.h index 7350c6c41..f05f2703e 100644 --- a/src/core/hle/kernel/process.h +++ b/src/core/hle/kernel/process.h @@ -93,13 +93,13 @@ private: class Process final : public Object { public: - static SharedPtr<Process> Create(SharedPtr<CodeSet> code_set); + static SharedPtr<Process> Create(std::string&& name); std::string GetTypeName() const override { return "Process"; } std::string GetName() const override { - return codeset->name; + return name; } static const HandleType HANDLE_TYPE = HandleType::Process; @@ -109,7 +109,6 @@ public: static u32 next_process_id; - SharedPtr<CodeSet> codeset; /// Resource limit descriptor for this process SharedPtr<ResourceLimit> resource_limit; @@ -138,7 +137,7 @@ public: /** * Applies address space changes and launches the process main thread. */ - void Run(s32 main_thread_priority, u32 stack_size); + void Run(VAddr entry_point, s32 main_thread_priority, u32 stack_size); void LoadModule(SharedPtr<CodeSet> module_, VAddr base_addr); @@ -166,6 +165,8 @@ public: /// This vector will grow as more pages are allocated for new threads. std::vector<std::bitset<8>> tls_slots; + std::string name; + VAddr GetLinearHeapAreaAddress() const; VAddr GetLinearHeapBase() const; VAddr GetLinearHeapLimit() const; diff --git a/src/core/loader/3dsx.cpp b/src/core/loader/3dsx.cpp index 74e336487..209328347 100644 --- a/src/core/loader/3dsx.cpp +++ b/src/core/loader/3dsx.cpp @@ -267,7 +267,8 @@ ResultStatus AppLoader_THREEDSX::Load() { return ResultStatus::Error; codeset->name = filename; - Kernel::g_current_process = Kernel::Process::Create(std::move(codeset)); + Kernel::g_current_process = Kernel::Process::Create("main"); + Kernel::g_current_process->LoadModule(codeset, codeset->entrypoint); Kernel::g_current_process->svc_access_mask.set(); Kernel::g_current_process->address_mappings = default_address_mappings; @@ -275,7 +276,7 @@ ResultStatus AppLoader_THREEDSX::Load() { Kernel::g_current_process->resource_limit = Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION); - Kernel::g_current_process->Run(48, Kernel::DEFAULT_STACK_SIZE); + Kernel::g_current_process->Run(codeset->entrypoint, 48, Kernel::DEFAULT_STACK_SIZE); Service::FS::RegisterArchiveType(std::make_unique<FileSys::ArchiveFactory_SelfNCCH>(*this), Service::FS::ArchiveIdCode::SelfNCCH); diff --git a/src/core/loader/elf.cpp b/src/core/loader/elf.cpp index 055bc39de..2efc67ff8 100644 --- a/src/core/loader/elf.cpp +++ b/src/core/loader/elf.cpp @@ -401,7 +401,8 @@ ResultStatus AppLoader_ELF::Load() { SharedPtr<CodeSet> codeset = elf_reader.LoadInto(Memory::PROCESS_IMAGE_VADDR); codeset->name = filename; - Kernel::g_current_process = Kernel::Process::Create(std::move(codeset)); + Kernel::g_current_process = Kernel::Process::Create("main"); + Kernel::g_current_process->LoadModule(codeset, codeset->entrypoint); Kernel::g_current_process->svc_access_mask.set(); Kernel::g_current_process->address_mappings = default_address_mappings; @@ -409,7 +410,7 @@ ResultStatus AppLoader_ELF::Load() { Kernel::g_current_process->resource_limit = Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION); - Kernel::g_current_process->Run(48, Kernel::DEFAULT_STACK_SIZE); + Kernel::g_current_process->Run(codeset->entrypoint, 48, Kernel::DEFAULT_STACK_SIZE); is_loaded = true; return ResultStatus::Success; diff --git a/src/core/loader/ncch.cpp b/src/core/loader/ncch.cpp index fc4d14a59..728886ea8 100644 --- a/src/core/loader/ncch.cpp +++ b/src/core/loader/ncch.cpp @@ -168,7 +168,8 @@ ResultStatus AppLoader_NCCH::LoadExec() { codeset->entrypoint = codeset->code.addr; codeset->memory = std::make_shared<std::vector<u8>>(std::move(code)); - Kernel::g_current_process = Kernel::Process::Create(std::move(codeset)); + Kernel::g_current_process = Kernel::Process::Create("main"); + Kernel::g_current_process->LoadModule(codeset, codeset->entrypoint); // Attach a resource limit to the process based on the resource limit category Kernel::g_current_process->resource_limit = @@ -187,7 +188,7 @@ ResultStatus AppLoader_NCCH::LoadExec() { s32 priority = exheader_header.arm11_system_local_caps.priority; u32 stack_size = exheader_header.codeset_info.stack_size; - Kernel::g_current_process->Run(priority, stack_size); + Kernel::g_current_process->Run(codeset->entrypoint, priority, stack_size); return ResultStatus::Success; } return ResultStatus::Error; diff --git a/src/core/loader/nso.cpp b/src/core/loader/nso.cpp index ca8c59cd5..f5083d122 100644 --- a/src/core/loader/nso.cpp +++ b/src/core/loader/nso.cpp @@ -2,8 +2,6 @@ // Licensed under GPLv2 or any later version // Refer to the license.txt file included. -#include <map> -#include <string> #include <vector> #include <lz4.h> @@ -14,22 +12,20 @@ #include "core/loader/nso.h" #include "core/memory.h" -using Kernel::CodeSet; -using Kernel::SharedPtr; - namespace Loader { -FileType AppLoader_NSO::IdentifyType(FileUtil::IOFile& file) { - u32 magic = 0; - file.Seek(0, SEEK_SET); - if (1 != file.ReadArray<u32>(&magic, 1)) - return FileType::Error; +enum class RelocationType : u32 { ABS64 = 257, GLOB_DAT = 1025, JUMP_SLOT = 1026, RELATIVE = 1027 }; - if (MakeMagic('N', 'S', 'O', '0') == magic) - return FileType::NSO; - - return FileType::Error; -} +enum DynamicType : u32 { + DT_NULL = 0, + DT_PLTRELSZ = 2, + DT_STRTAB = 5, + DT_SYMTAB = 6, + DT_RELA = 7, + DT_RELASZ = 8, + DT_STRSZ = 10, + DT_JMPREL = 23, +}; struct NsoSegmentHeader { u32_le offset; @@ -42,13 +38,40 @@ static_assert(sizeof(NsoSegmentHeader) == 0x10, "NsoSegmentHeader has incorrect struct NsoHeader { u32_le magic; INSERT_PADDING_BYTES(0xc); - std::array<NsoSegmentHeader, 3> segments; // Text, Data, RoData (in that order) - INSERT_PADDING_BYTES(0x20); + std::array<NsoSegmentHeader, 3> segments; // Text, RoData, Data (in that order) + u32_le bss_size; + INSERT_PADDING_BYTES(0x1c); std::array<u32_le, 3> segments_compressed_size; }; - static_assert(sizeof(NsoHeader) == 0x6c, "NsoHeader has incorrect size."); +struct ModHeader { + INSERT_PADDING_BYTES(0x4); + u32_le offset_to_start; // Always 8 + u32_le magic; + u32_le dynamic_offset; + u32_le bss_start_offset; + u32_le bss_end_offset; + u32_le eh_frame_hdr_start_offset; + u32_le eh_frame_hdr_end_offset; + u32_le module_offset; // Offset to runtime-generated module object. typically equal to .bss base +}; +static_assert(sizeof(ModHeader) == 0x24, "ModHeader has incorrect size."); + +FileType AppLoader_NSO::IdentifyType(FileUtil::IOFile& file) { + u32 magic = 0; + file.Seek(0, SEEK_SET); + if (1 != file.ReadArray<u32>(&magic, 1)) { + return FileType::Error; + } + + if (MakeMagic('N', 'S', 'O', '0') == magic) { + return FileType::NSO; + } + + return FileType::Error; +} + static std::vector<u8> ReadSegment(FileUtil::IOFile& file, const NsoSegmentHeader& header, int compressed_size) { std::vector<u8> compressed_data; @@ -72,40 +95,10 @@ static std::vector<u8> ReadSegment(FileUtil::IOFile& file, const NsoSegmentHeade return uncompressed_data; } -struct Symbol { - Symbol(std::string&& name, u64 value) : name(std::move(name)), value(value) {} - std::string name; - u64 value; -}; - -struct Import { - VAddr ea; - s64 addend; -}; - -enum class RelocationType : u32 { - ABS64 = 257, - GLOB_DAT = 1025, - JUMP_SLOT = 1026, - RELATIVE = 1027 -}; - -enum DynamicType : u32 { - DT_NULL = 0, - DT_PLTRELSZ = 2, - DT_STRTAB = 5, - DT_SYMTAB = 6, - DT_RELA = 7, - DT_RELASZ = 8, - DT_STRSZ = 10, - DT_JMPREL = 23, -}; - -void WriteRelocations(const std::vector<Symbol>& symbols, VAddr loadbase, u64 roff, u64 size, - bool is_jump_relocation, std::map<std::string, Import>& imports, - std::map<std::string, VAddr>& exports) { +void AppLoader_NSO::WriteRelocations(const std::vector<Symbol>& symbols, VAddr load_base, + u64 relocation_offset, u64 size, bool is_jump_relocation) { for (u64 i = 0; i < size; i += 0x18) { - VAddr addr = loadbase + roff + i; + VAddr addr = load_base + relocation_offset + i; u64 offset = Memory::Read64(addr); u64 info = Memory::Read64(addr + 8); u64 addend_unsigned = Memory::Read64(addr + 16); @@ -114,16 +107,16 @@ void WriteRelocations(const std::vector<Symbol>& symbols, VAddr loadbase, u64 ro RelocationType rtype = static_cast<RelocationType>(info & 0xFFFFFFFF); u32 rsym = static_cast<u32>(info >> 32); - VAddr ea = loadbase + offset; + VAddr ea = load_base + offset; const Symbol& symbol = symbols[rsym]; switch (rtype) { case RelocationType::RELATIVE: if (!symbol.name.empty()) { - exports[symbol.name] = loadbase + addend; + exports[symbol.name] = load_base + addend; } - Memory::Write64(ea, loadbase + addend); + Memory::Write64(ea, load_base + addend); break; case RelocationType::JUMP_SLOT: case RelocationType::GLOB_DAT: @@ -149,18 +142,12 @@ void WriteRelocations(const std::vector<Symbol>& symbols, VAddr loadbase, u64 ro } } -void Relocate(VAddr loadbase, std::map<std::string, Import>& imports, - std::map<std::string, VAddr>& exports) { - u32 modoff = Memory::Read32(loadbase + 4); - ASSERT_MSG(Memory::Read32(loadbase + modoff) == MakeMagic('M', 'O', 'D', '0'), - "Expected MOD section"); - - u64 dynoff = loadbase + modoff + Memory::Read32(loadbase + modoff + 4); +void AppLoader_NSO::Relocate(VAddr load_base, VAddr dynamic_section_addr) { std::map<u64, u64> dynamic; while (1) { - u64 tag = Memory::Read64(dynoff); - u64 value = Memory::Read64(dynoff + 8); - dynoff += 16; + u64 tag = Memory::Read64(dynamic_section_addr); + u64 value = Memory::Read64(dynamic_section_addr + 8); + dynamic_section_addr += 16; if (tag == DT_NULL) { break; @@ -171,9 +158,9 @@ void Relocate(VAddr loadbase, std::map<std::string, Import>& imports, u64 strtabsize = dynamic[DT_STRSZ]; std::vector<u8> strtab; strtab.resize(strtabsize); - Memory::ReadBlock(loadbase + dynamic[DT_STRTAB], strtab.data(), strtabsize); + Memory::ReadBlock(load_base + dynamic[DT_STRTAB], strtab.data(), strtabsize); - VAddr addr = loadbase + dynamic[DT_SYMTAB]; + VAddr addr = load_base + dynamic[DT_SYMTAB]; std::vector<Symbol> symbols; while (1) { const u32 stname = Memory::Read32(addr); @@ -187,96 +174,108 @@ void Relocate(VAddr loadbase, std::map<std::string, Import>& imports, std::string name = reinterpret_cast<char*>(&strtab[stname]); if (stvalue) { - exports[name] = loadbase + stvalue; - symbols.emplace_back(std::move(name), loadbase + stvalue); + exports[name] = load_base + stvalue; + symbols.emplace_back(std::move(name), load_base + stvalue); } else { symbols.emplace_back(std::move(name), 0); } } if (dynamic.find(DT_RELA) != dynamic.end()) { - WriteRelocations(symbols, loadbase, dynamic[DT_RELA], dynamic[DT_RELASZ], false, imports, - exports); + WriteRelocations(symbols, load_base, dynamic[DT_RELA], dynamic[DT_RELASZ], false); } if (dynamic.find(DT_JMPREL) != dynamic.end()) { - WriteRelocations(symbols, loadbase, dynamic[DT_JMPREL], dynamic[DT_PLTRELSZ], true, imports, - exports); + WriteRelocations(symbols, load_base, dynamic[DT_JMPREL], dynamic[DT_PLTRELSZ], true); } } -static VAddr GetEntryPoint(const std::map<std::string, VAddr>& exports) { +VAddr AppLoader_NSO::GetEntryPoint() const { // Find nnMain function, set entrypoint to that address const auto& search = exports.find("nnMain"); if (search != exports.end()) { return search->second; } + ASSERT_MSG(false, "Unable to find entrypoint"); return {}; } -static SharedPtr<CodeSet> LoadModule(const std::string& filepath, VAddr loadbase, - std::map<std::string, Import>& imports, - std::map<std::string, VAddr>& exports) { - FileUtil::IOFile file(filepath, "rb"); +static constexpr u32 PageAlignSize(u32 size) { + return (size + Memory::PAGE_MASK) & ~Memory::PAGE_MASK; +} - if (!file.IsOpen()) +bool AppLoader_NSO::LoadNso(const std::string& path, VAddr load_base) { + FileUtil::IOFile file(path, "rb"); + if (!file.IsOpen()) { return {}; + } - NsoHeader header{}; + // Read NSO header + NsoHeader nso_header{}; file.Seek(0, SEEK_SET); - if (sizeof(NsoHeader) != file.ReadBytes(&header, sizeof(NsoHeader))) + if (sizeof(NsoHeader) != file.ReadBytes(&nso_header, sizeof(NsoHeader))) { + return {}; + } + if (nso_header.magic != MakeMagic('N', 'S', 'O', '0')) { return {}; + } // Build program image - SharedPtr<CodeSet> codeset = CodeSet::Create("", 0); + Kernel::SharedPtr<Kernel::CodeSet> codeset = Kernel::CodeSet::Create("", 0); std::vector<u8> program_image; - for (int i = 0; i < header.segments.size(); ++i) { + for (int i = 0; i < nso_header.segments.size(); ++i) { std::vector<u8> data = - ReadSegment(file, header.segments[i], header.segments_compressed_size[i]); - program_image.resize(header.segments[i].location); + ReadSegment(file, nso_header.segments[i], nso_header.segments_compressed_size[i]); + program_image.resize(nso_header.segments[i].location); program_image.insert(program_image.end(), data.begin(), data.end()); - codeset->segments[i].addr = header.segments[i].location; - codeset->segments[i].offset = header.segments[i].location; - codeset->segments[i].size = (data.size() + Memory::PAGE_MASK) & ~Memory::PAGE_MASK; + codeset->segments[i].addr = nso_header.segments[i].location; + codeset->segments[i].offset = nso_header.segments[i].location; + codeset->segments[i].size = static_cast<u32>(data.size()); + } + + // Read MOD header + ModHeader mod_header{}; + std::memcpy(&mod_header, program_image.data(), sizeof(ModHeader)); + if (mod_header.magic != MakeMagic('M', 'O', 'D', '0')) { + return {}; } - program_image.resize((program_image.size() + Memory::PAGE_MASK) & ~Memory::PAGE_MASK); - codeset->name = filepath; - codeset->entrypoint = 0; // Set after relocation + // Resize program image to include .bss section and page align each section + const u32 bss_size = mod_header.bss_end_offset - mod_header.bss_start_offset; + codeset->code.size = PageAlignSize(codeset->code.size); + codeset->rodata.size = PageAlignSize(codeset->rodata.size); + codeset->data.size = PageAlignSize(codeset->data.size + bss_size); + program_image.resize(PageAlignSize(static_cast<u32>(program_image.size()) + bss_size)); + + // Load codeset for current process + codeset->name = path; codeset->memory = std::make_shared<std::vector<u8>>(std::move(program_image)); + Kernel::g_current_process->LoadModule(codeset, load_base); + Relocate(load_base, load_base + mod_header.offset_to_start + mod_header.dynamic_offset); - return codeset; + return true; } ResultStatus AppLoader_NSO::Load() { - if (is_loaded) + if (is_loaded) { return ResultStatus::ErrorAlreadyLoaded; - - if (!file.IsOpen()) + } + if (!file.IsOpen()) { return ResultStatus::Error; + } - static constexpr VAddr loadbase = 0x7100000000; - std::map<std::string, Import> imports; - std::map<std::string, VAddr> exports; + // Load and relocate "main" and "sdk" NSO + const std::string sdkpath = filepath.substr(0, filepath.find_last_of("/\\")) + "/sdk"; + Kernel::g_current_process = Kernel::Process::Create("main"); + if (!LoadNso(filepath, 0x10000000) || !LoadNso(sdkpath, 0x20000000)) { + return ResultStatus::ErrorInvalidFormat; + } - // Load and relocate "main" NSO - auto codeset = LoadModule(filepath, loadbase, imports, exports); - Kernel::g_current_process = Kernel::Process::Create(codeset); Kernel::g_current_process->svc_access_mask.set(); Kernel::g_current_process->address_mappings = default_address_mappings; Kernel::g_current_process->resource_limit = Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION); - Kernel::g_current_process->LoadModule(codeset, loadbase); - Relocate(loadbase, imports, exports); - codeset->entrypoint = GetEntryPoint(exports); - Kernel::g_current_process->Run(48, Kernel::DEFAULT_STACK_SIZE); - - // Load and relocate "sdk" NSO - static constexpr VAddr sdkbase = 0x7200000000; - const std::string sdkpath = filepath.substr(0, filepath.find_last_of("/\\")) + "/sdk"; - auto sdk_codeset = LoadModule(sdkpath, sdkbase, imports, exports); - Kernel::g_current_process->LoadModule(sdk_codeset, sdkbase); - Relocate(sdkbase, imports, exports); + Kernel::g_current_process->Run(GetEntryPoint(), 48, Kernel::DEFAULT_STACK_SIZE); // Resolve imports for (const auto& import : imports) { @@ -284,7 +283,7 @@ ResultStatus AppLoader_NSO::Load() { if (search != exports.end()) { Memory::Write64(import.second.ea, search->second + import.second.addend); } else { - LOG_CRITICAL(Loader, "Unresolved import: %s", import.first.c_str()); + LOG_ERROR(Loader, "Unresolved import: %s", import.first.c_str()); } } diff --git a/src/core/loader/nso.h b/src/core/loader/nso.h index 39a9bd3d9..2d9e60ad7 100644 --- a/src/core/loader/nso.h +++ b/src/core/loader/nso.h @@ -4,9 +4,11 @@ #pragma once +#include <map> #include <string> #include "common/common_types.h" #include "common/file_util.h" +#include "core/hle/kernel/kernel.h" #include "core/loader/loader.h" namespace Loader { @@ -15,7 +17,8 @@ namespace Loader { class AppLoader_NSO final : public AppLoader { public: AppLoader_NSO(FileUtil::IOFile&& file, std::string filename, std::string filepath) - : AppLoader(std::move(file)), filename(std::move(filename)), filepath(std::move(filepath)) {} + : AppLoader(std::move(file)), filename(std::move(filename)), filepath(std::move(filepath)) { + } /** * Returns the type of the file @@ -31,6 +34,26 @@ public: ResultStatus Load() override; private: + struct Symbol { + Symbol(std::string&& name, u64 value) : name(std::move(name)), value(value) {} + std::string name; + u64 value; + }; + + struct Import { + VAddr ea; + s64 addend; + }; + + void WriteRelocations(const std::vector<Symbol>& symbols, VAddr load_base, + u64 relocation_offset, u64 size, bool is_jump_relocation); + VAddr GetEntryPoint() const; + bool LoadNso(const std::string& path, VAddr load_base); + void Relocate(VAddr load_base, VAddr dynamic_section_addr); + + std::map<std::string, Import> imports; + std::map<std::string, VAddr> exports; + std::string filename; std::string filepath; }; diff --git a/src/tests/core/hle/kernel/hle_ipc.cpp b/src/tests/core/hle/kernel/hle_ipc.cpp index 52336d027..4143a3ab8 100644 --- a/src/tests/core/hle/kernel/hle_ipc.cpp +++ b/src/tests/core/hle/kernel/hle_ipc.cpp @@ -22,7 +22,7 @@ TEST_CASE("HLERequestContext::PopulateFromIncomingCommandBuffer", "[core][kernel auto session = std::get<SharedPtr<ServerSession>>(ServerSession::CreateSessionPair()); HLERequestContext context(std::move(session)); - auto process = Process::Create(CodeSet::Create("", 0)); + auto process = Process::Create(""); HandleTable handle_table; SECTION("works with empty cmdbuf") { @@ -142,7 +142,7 @@ TEST_CASE("HLERequestContext::WriteToOutgoingCommandBuffer", "[core][kernel]") { auto session = std::get<SharedPtr<ServerSession>>(ServerSession::CreateSessionPair()); HLERequestContext context(std::move(session)); - auto process = Process::Create(CodeSet::Create("", 0)); + auto process = Process::Create(""); HandleTable handle_table; auto* input = context.CommandBuffer(); u32_le output[IPC::COMMAND_BUFFER_LENGTH]; |